home *** CD-ROM | disk | FTP | other *** search
/ Linux Cubed Series 7: Sunsite / Linux Cubed Series 7 - Sunsite Vol 1.iso / system / network / samba / patches / samba-1.043 / samba-1
Text File  |  1995-11-07  |  180KB  |  6,168 lines
  1. diff -u -r --new-file last-version/docs/smb.conf.5 samba-1.9.14p3/docs/smb.conf.5
  2. --- last-version/docs/smb.conf.5    Sun Sep 17 10:28:23 1995
  3. +++ samba-1.9.14p3/docs/smb.conf.5    Sun Nov  5 11:35:38 1995
  4. @@ -1510,7 +1510,7 @@
  5.  
  6.  The string can contain the macros %o and %n which are substituted for
  7.  the old and new passwords respectively. It can aso contain the
  8. -standard macros \n \r \t and \s to give line-feed, carriage-return,
  9. +standard macros \\n \\r \\t and \\s to give line-feed, carriage-return,
  10.  tab and space.
  11.  
  12.  The string can also contain a * which matches any sequence of
  13. @@ -1524,11 +1524,11 @@
  14.  then no string is expected.
  15.  
  16.  .B Example:
  17. -    passwd chat = "*Enter OLD password*" %o\n "*Enter NEW password*" %n\n \
  18. -                      "*Reenter NEW password*" %n\n "*Password changed*"
  19. +    passwd chat = "*Enter OLD password*" %o\\n "*Enter NEW password*" %n\\n \\
  20. +                      "*Reenter NEW password*" %n\\n "*Password changed*"
  21.  
  22.  .B Default:
  23. -    passwd chat = *old*password* %o\n *new*password* %n\n *new*password* %n\n *changed*
  24. +    passwd chat = *old*password* %o\\n *new*password* %n\\n *new*password* %n\\n *changed*
  25.  
  26.  .SS passwd program (G)
  27.  The name of a program that can be used to set user passwords.
  28. diff -u -r --new-file last-version/source/Makefile samba-1.9.14p3/source/Makefile
  29. --- last-version/source/Makefile    Thu Sep 21 20:24:34 1995
  30. +++ samba-1.9.14p3/source/Makefile    Tue Nov  7 22:58:21 1995
  31. @@ -422,7 +422,8 @@
  32.  CFLAGS  = $(CFLAGS5) $(DCE_FLAGS) $(DES_FLAGS) $(PASSWD_FLAGS) $(VTP_FLAGS)
  33.  LIBS = $(LIBS1) $(LIBSM) $(DCE_LIBS) $(DES_LIB)
  34.  
  35. -PROGS = smbd smbclient nmbd testparm testprns smbrun smbstatus smbpasswd
  36. +PROGS1 = smbd smbclient nmbd testparm testprns smbrun smbstatus smbpasswd 
  37. +PROGS = $(PROGS1) nmbd2
  38.  SCRIPTS = smbtar
  39.  
  40.  all : CHECK $(PROGS)
  41. @@ -436,8 +437,10 @@
  42.  INCLUDES2 = pcap.h trans2.h reply.h
  43.  INCLUDES = $(INCLUDES1) $(INCLUDES2)
  44.  
  45. -UTILOBJ = util.o system.o charset.o kanji.o fault.o smbencrypt.o charcnv.o
  46. -PARAMOBJ = $(UTILOBJ) loadparm.o params.o pcap.o access.o username.o ufc.o smbpass.o
  47. +UTILOBJ1 = util.o system.o charset.o kanji.o fault.o smbencrypt.o charcnv.o
  48. +UTILOBJ = $(UTILOBJ1) md4.o
  49. +PARAMOBJ1 = $(UTILOBJ) loadparm.o params.o pcap.o access.o username.o
  50. +PARAMOBJ = $(PARAMOBJ1) ufc.o smbpass.o 
  51.  SMBDOBJ1 = $(PARAMOBJ) trans2.o message.o dir.o printing.o locking.o
  52.  SMBDOBJ2 = ipc.o reply.o mangle.o chgpasswd.o password.o
  53.  SMBDOBJ = $(SMBDOBJ1) $(SMBDOBJ2) $(VTP_OBJ)
  54. @@ -457,9 +460,13 @@
  55.      @echo Linking smbrun
  56.      @$(CC) $(CFLAGS) -o smbrun smbrun.o $(LIBS)
  57.  
  58. -nmbd: nameserv.o $(UTILOBJ) 
  59. +nmbd: nameserv.o $(UTILOBJ)  
  60.      @echo Linking nmbd
  61.      @$(CC) $(CFLAGS) -o nmbd nameserv.o $(UTILOBJ) $(LIBS)
  62. +
  63. +nmbd2: nameserv2.o nmblib.o $(UTILOBJ) 
  64. +    @echo Linking nmbd2
  65. +    @$(CC) $(CFLAGS) -o nmbd2 nameserv2.o nmblib.o $(UTILOBJ) $(LIBS)
  66.  
  67.  smbclient: client.o clitar.o $(UTILOBJ) 
  68.      @echo Linking smbclient
  69. diff -u -r --new-file last-version/source/change-log samba-1.9.14p3/source/change-log
  70. --- last-version/source/change-log    Sat Nov  4 23:21:02 1995
  71. +++ samba-1.9.14p3/source/change-log    Tue Nov  7 22:59:06 1995
  72. @@ -1617,9 +1617,18 @@
  73.      - made rename and unlink look at share locks on file
  74.      - clitar memory leak fix from jjm@jjm.com
  75.      - added -p option to smbstatus to list smbd processes
  76. +    - added rename to the client
  77.      - released p2
  78. +    - fixed SMBmv for case where the destination exists
  79. +    - man page patch from michal@ellpspace.math.ualberta.ca (Michal Jaegermann)
  80. +    - once again redid the time handling, but finally explained what
  81. +    is going on, this is written up in TIME.txt. The "kludge-GMT" used
  82. +    by NT is a bastard and led to a lot of the confusion
  83. +    - kanji patch from fujita@ainix.isac.co.jp (Takashi Fujita)
  84. +    - is08859-1 patches from eauth@mail.cso.co.at
  85. +    - starting rewriting nmbd, new nmbd is nmbd2, old one still around
  86. +    for time being
  87.  
  88. -
  89.  ==========
  90.  todo:
  91.  
  92. @@ -1653,6 +1662,10 @@
  93.  document cnvchar stuff
  94.  
  95.  allow smbd to serve user and group lists to win95
  96. +
  97. +document homes behaviour with WinDD
  98. +
  99. +apparently WfWg doesn't like the password server stuff in 1.9.14. Why?
  100.  
  101.  UNRESOLVED PROBLEMS
  102.  ===================
  103. diff -u -r --new-file last-version/source/client.c samba-1.9.14p3/source/client.c
  104. --- last-version/source/client.c    Sat Nov  4 21:31:10 1995
  105. +++ samba-1.9.14p3/source/client.c    Tue Nov  7 13:59:55 1995
  106. @@ -444,12 +444,12 @@
  107.    ****************************************************************************/
  108.  static void display_finfo(file_info *finfo)
  109.  {
  110. -  time_t t = finfo->mtime - DSTDiff(finfo->mtime);
  111. +  time_t t = finfo->mtime; /* the time is assumed to be passed as GMT */
  112.    DEBUG(0,("  %-30s%7.7s%10d  %s",
  113.         CNV_LANG(finfo->name),
  114.         attrib_string(finfo->mode),
  115.         finfo->size,
  116. -       asctime(LocalTime(&t,0))));
  117. +       asctime(LocalTime(&t,GMT_TO_LOCAL))));
  118.  }
  119.  
  120.  /****************************************************************************
  121. @@ -492,7 +492,8 @@
  122.  {
  123.    finfo->mode = CVAL(p,21);
  124.  
  125. -  finfo->ctime = make_unix_date(p+22,True);
  126. +  /* this date is converted to GMT by make_unix_date */
  127. +  finfo->ctime = make_unix_date(p+22);
  128.    finfo->mtime = finfo->atime = finfo->ctime;
  129.    finfo->size = IVAL(p,26);
  130.    strcpy(finfo->name,p+30);
  131. @@ -516,9 +517,10 @@
  132.      case 1: /* OS/2 understands this */
  133.        if (finfo)
  134.      {
  135. -      finfo->ctime = make_unix_date2(p+4,True);
  136. -      finfo->atime = make_unix_date2(p+8,True);
  137. -      finfo->mtime = make_unix_date2(p+12,True);
  138. +      /* these dates are converted to GMT by make_unix_date */
  139. +      finfo->ctime = make_unix_date2(p+4);
  140. +      finfo->atime = make_unix_date2(p+8);
  141. +      finfo->mtime = make_unix_date2(p+12);
  142.        finfo->size = IVAL(p,16);
  143.        finfo->mode = CVAL(p,24);
  144.        strcpy(finfo->name,p+27);
  145. @@ -528,9 +530,10 @@
  146.      case 2: /* this is what OS/2 uses mostly */
  147.        if (finfo)
  148.      {
  149. -      finfo->ctime = make_unix_date2(p+4,True);
  150. -      finfo->atime = make_unix_date2(p+8,True);
  151. -      finfo->mtime = make_unix_date2(p+12,True);
  152. +      /* these dates are converted to GMT by make_unix_date */
  153. +      finfo->ctime = make_unix_date2(p+4);
  154. +      finfo->atime = make_unix_date2(p+8);
  155. +      finfo->mtime = make_unix_date2(p+12);
  156.        finfo->size = IVAL(p,16);
  157.        finfo->mode = CVAL(p,24);
  158.        strcpy(finfo->name,p+31);
  159. @@ -541,9 +544,10 @@
  160.      case 3:
  161.        if (finfo)
  162.      {
  163. -      finfo->ctime = make_unix_date2(p+8,True);
  164. -      finfo->atime = make_unix_date2(p+12,True);
  165. -      finfo->mtime = make_unix_date2(p+16,True);
  166. +      /* these dates are probably like the other ones */
  167. +      finfo->ctime = make_unix_date2(p+8);
  168. +      finfo->atime = make_unix_date2(p+12);
  169. +      finfo->mtime = make_unix_date2(p+16);
  170.        finfo->size = IVAL(p,20);
  171.        finfo->mode = CVAL(p,28);
  172.        strcpy(finfo->name,p+33);
  173. @@ -553,9 +557,10 @@
  174.      case 4:
  175.        if (finfo)
  176.      {
  177. -      finfo->ctime = make_unix_date2(p+8,True);
  178. -      finfo->atime = make_unix_date2(p+12,True);
  179. -      finfo->mtime = make_unix_date2(p+16,True);
  180. +      /* these dates are probably like the other ones */
  181. +      finfo->ctime = make_unix_date2(p+8);
  182. +      finfo->atime = make_unix_date2(p+12);
  183. +      finfo->mtime = make_unix_date2(p+16);
  184.        finfo->size = IVAL(p,20);
  185.        finfo->mode = CVAL(p,28);
  186.        strcpy(finfo->name,p+37);
  187. @@ -565,17 +570,24 @@
  188.      case 260: /* NT uses this, but also accepts 2 */
  189.        if (finfo)
  190.      {
  191. -      extern int serverzone;
  192.        int ret = SVAL(p,0);
  193.        int namelen;
  194.        p += 4; /* next entry offset */
  195.        p += 4; /* fileindex */
  196. +
  197. +      /* these dates appear to arrive in a weird way. It seems to
  198. +         be localtime plus the serverzone given in the initial
  199. +         connect. This is GMT when DST is not in effect and one
  200. +         hour from GMT otherwise. Can this really be right??
  201. +
  202. +         I suppose this could be called kludge-GMT. Is is the GMT
  203. +         you get by using the current DST setting on a different
  204. +         localtime. It will be cheap to calculate, I suppose, as
  205. +         no DST tables will be needed */
  206. +
  207.        finfo->ctime = interpret_long_date(p); p += 8;
  208.        finfo->atime = interpret_long_date(p); p += 8;
  209.        finfo->mtime = interpret_long_date(p); p += 8; p += 8;
  210. -      finfo->mtime += DSTDiff(finfo->mtime) - serverzone;
  211. -      finfo->ctime += DSTDiff(finfo->ctime) - serverzone;
  212. -      finfo->atime += DSTDiff(finfo->atime) - serverzone;
  213.        finfo->size = IVAL(p,0); p += 8;
  214.        p += 8; /* alloc size */
  215.        finfo->mode = CVAL(p,0); p += 4;
  216. @@ -1161,12 +1173,15 @@
  217.      }
  218.  
  219.    strcpy(finfo.name,rname);
  220. +
  221.    if (!finfo1)
  222.      {
  223.        finfo.mode = SVAL(inbuf,smb_vwv3);
  224. -      finfo.mtime = IVAL(inbuf,smb_vwv4);
  225. -      finfo.size = IVAL(inbuf,smb_vwv6);
  226. +      /* these times arrive as LOCAL time, using the DST offset 
  227. +     corresponding to that time, we convert them to GMT */
  228. +      finfo.mtime = make_unix_date3(inbuf+smb_vwv4);
  229.        finfo.atime = finfo.ctime = finfo.mtime;
  230. +      finfo.size = IVAL(inbuf,smb_vwv6);
  231.      }
  232.  
  233.    DEBUG(3,("file %s attrib 0x%X\n",CNV_LANG(finfo.name),finfo.mode));
  234. @@ -1536,7 +1551,8 @@
  235.      if (lowercase)
  236.        strlower(finfo->name);
  237.  
  238. -    if (!directory_exist(finfo->name) && sys_mkdir(finfo->name,0777) != 0) 
  239. +    if (!directory_exist(finfo->name,NULL) && 
  240. +        sys_mkdir(finfo->name,0777) != 0) 
  241.        {
  242.          DEBUG(0,("failed to create directory %s\n",CNV_LANG(finfo->name)));
  243.          strcpy(cur_dir,saved_curdir);
  244. @@ -1834,25 +1850,18 @@
  245.        return;
  246.      }
  247.  
  248. -  if (close_time != 0 && close_time != -1) 
  249. -    close_time -= TimeDiff(close_time);
  250. -  
  251.    bzero(outbuf,smb_size);
  252.    set_message(outbuf,3,2 + strlen(rname),True);
  253.  
  254.    if (finfo->mtime == 0 || finfo->mtime == -1)
  255. -    {
  256. -      time_t t = time(NULL);
  257. -      finfo->mtime = finfo->atime = finfo->ctime = 
  258. -    t + GMT_TO_LOCAL*TimeDiff(t);
  259. -    }
  260. -  
  261. +    finfo->mtime = finfo->atime = finfo->ctime = time(NULL);
  262. +
  263.    CVAL(outbuf,smb_com) = SMBcreate;
  264.    SSVAL(outbuf,smb_tid,cnum);
  265.    setup_pkt(outbuf);
  266.  
  267.    SSVAL(outbuf,smb_vwv0,finfo->mode);
  268. -  SIVAL(outbuf,smb_vwv1,finfo->mtime);
  269. +  put_dos_date3(outbuf,smb_vwv1,finfo->mtime);
  270.    
  271.    p = smb_buf(outbuf);
  272.    *p++ = 4;      
  273. @@ -1927,12 +1936,8 @@
  274.    SSVAL(outbuf,smb_tid,cnum);
  275.    setup_pkt(outbuf);
  276.  
  277. -  SSVAL(outbuf,smb_vwv0,fnum);
  278. -  SIVAL(outbuf,smb_vwv1,close_time);
  279. -
  280. -  DEBUG(3,("Setting date to %s (0x%X)",
  281. -       asctime(LocalTime(&finfo->mtime,LOCAL_TO_GMT)),
  282. -       finfo->mtime));
  283. +  SSVAL(outbuf,smb_vwv0,fnum);  
  284. +  put_dos_date3(outbuf,smb_vwv1,close_time);
  285.  
  286.    send_smb(outbuf);
  287.    receive_smb(inbuf,CLIENT_TIMEOUT);
  288. @@ -2000,8 +2005,14 @@
  289.  
  290.    dos_clean_name(rname);
  291.  
  292. -  /* let the remote side decide the date */
  293. -  finfo.mtime = -1;
  294. +  {
  295. +    struct stat st;
  296. +    if (!file_exist(lname,&st)) {
  297. +      DEBUG(0,("%s does not exist\n"));
  298. +      return;
  299. +    }
  300. +    finfo.mtime = st.st_mtime;
  301. +  }
  302.  
  303.    do_put(rname,lname,&finfo);
  304.  }
  305. @@ -2054,6 +2065,7 @@
  306.    
  307.    while (next_token(NULL,p,NULL))
  308.      {
  309. +      struct stat st;
  310.        pstring cmd;
  311.        pstring tmpname;
  312.        FILE *f;
  313. @@ -2078,7 +2090,7 @@
  314.      again1:
  315.  
  316.        /* check if it's a directory */
  317. -      if (directory_exist(lname))
  318. +      if (directory_exist(lname,&st))
  319.          {
  320.            if (!recurse) continue;
  321.            sprintf(quest,"Put directory %s? ",lname);
  322. @@ -2115,8 +2127,8 @@
  323.        /* null size so do_put knows to ignore it */
  324.        finfo.size = -1;
  325.  
  326. -      /* let the remote side decide the date */
  327. -      finfo.mtime = -1;
  328. +      /* set the date on the file */
  329. +      finfo.mtime = st.st_mtime;
  330.  
  331.        do_put(rname,lname,&finfo);
  332.      }
  333. @@ -2584,8 +2596,9 @@
  334.    ok = next_token(NULL,buf,NULL);
  335.    if (ok && (sys_stat(buf,&sbuf) == 0))
  336.      {
  337. -      newer_than = sbuf.st_mtime + GMT_TO_LOCAL*TimeDiff(sbuf.st_mtime);
  338. -      DEBUG(1,("Getting files newer than %s",asctime(LocalTime(&newer_than,0))));
  339. +      newer_than = sbuf.st_mtime;
  340. +      DEBUG(1,("Getting files newer than %s",
  341. +           asctime(LocalTime(&newer_than,GMT_TO_LOCAL))));
  342.      }
  343.    else
  344.      newer_than = 0;
  345. @@ -2895,8 +2908,9 @@
  346.      sec_mode = SVAL(inbuf,smb_vwv1);
  347.      max_xmit = SVAL(inbuf,smb_vwv2);
  348.      sesskey = IVAL(inbuf,smb_vwv6);
  349. -    servertime = make_unix_date(inbuf+smb_vwv8,False);
  350.      serverzone = SVALS(inbuf,smb_vwv10)*60;
  351. +    /* this time is converted to GMT by make_unix_date */
  352. +    servertime = make_unix_date(inbuf+smb_vwv8);
  353.      if (Protocol >= PROTOCOL_COREPLUS) {
  354.        readbraw_supported = ((SVAL(inbuf,smb_vwv5) & 0x1) != 0);
  355.        writebraw_supported = ((SVAL(inbuf,smb_vwv5) & 0x2) != 0);
  356. @@ -2913,8 +2927,8 @@
  357.      max_xmit = IVAL(inbuf,smb_vwv3+1);
  358.      sesskey = IVAL(inbuf,smb_vwv7+1);
  359.      serverzone = SVALS(inbuf,smb_vwv15+1)*60;
  360. +    /* this time arrives in real GMT */
  361.      servertime = interpret_long_date(inbuf+smb_vwv11+1);
  362. -    servertime -= serverzone;
  363.      crypt_len = CVAL(inbuf,smb_vwv16+1);
  364.      memcpy(cryptkey,smb_buf(inbuf),8);
  365.      if (IVAL(inbuf,smb_vwv9+1) & 1)
  366. @@ -2937,7 +2951,7 @@
  367.      static BOOL done_time = False;
  368.      if (!done_time) {
  369.        DEBUG(1,("Server time is %sTimezone is UTC%+02.1f\n",
  370. -           asctime(LocalTime(&servertime,0)),
  371. +           asctime(LocalTime(&servertime,GMT_TO_LOCAL)),
  372.             -(double)(serverzone/3600.0)));
  373.        done_time = True;
  374.      }
  375. @@ -3805,12 +3819,13 @@
  376.    pstring query_host;
  377.    BOOL message = False;
  378.  
  379. -  charset_initialise();
  380. -
  381.    *query_host = 0;
  382.  
  383.    DEBUGLEVEL = 2;
  384.    dbf = stdout;
  385. +
  386. +  TimeInit();
  387. +  charset_initialise();
  388.  
  389.    pid = getpid();
  390.    uid = getuid();
  391. diff -u -r --new-file last-version/source/clitar.c samba-1.9.14p3/source/clitar.c
  392. --- last-version/source/clitar.c    Sat Nov  4 23:05:01 1995
  393. +++ samba-1.9.14p3/source/clitar.c    Mon Nov  6 16:17:43 1995
  394. @@ -441,7 +441,7 @@
  395.      {
  396.        finfo.mode = SVAL(inbuf,smb_vwv3);
  397.        finfo.size = IVAL(inbuf,smb_vwv4);
  398. -      finfo.mtime = IVAL(inbuf,smb_vwv6);
  399. +      finfo.mtime = make_unix_date3(inbuf+smb_vwv6);
  400.        finfo.atime = finfo.ctime = finfo.mtime;
  401.      }
  402.  
  403. @@ -856,7 +856,6 @@
  404.     */
  405.    finfo->mtime = finfo->ctime = strtol(hb->dbuf.mtime, NULL, 8);
  406.    finfo->atime = time(NULL);
  407. -  finfo->atime += GMT_TO_LOCAL*TimeDiff(finfo->atime);
  408.    finfo->size = unoct(hb->dbuf.size, sizeof(hb->dbuf.size));
  409.  
  410.    return True;
  411. @@ -923,7 +922,7 @@
  412.    setup_pkt(outbuf);
  413.    
  414.    SSVAL(outbuf,smb_vwv0,finfo.mode);
  415. -  SIVAL(outbuf,smb_vwv1,finfo.mtime);
  416. +  put_dos_date3(outbuf,smb_vwv1,finfo.mtime);
  417.    
  418.    p = smb_buf(outbuf);
  419.    *p++ = 4;      
  420. @@ -996,10 +995,10 @@
  421.    setup_pkt(outbuf);
  422.    
  423.    SSVAL(outbuf,smb_vwv0,fnum);
  424. -  SIVAL(outbuf,smb_vwv1,finfo.mtime-TimeDiff(finfo.mtime));
  425. +  put_dos_date3(outbuf,smb_vwv1,finfo.mtime);
  426.    
  427.    DEBUG(3,("Setting date to %s (0x%X)",
  428. -       asctime(LocalTime(&finfo.mtime,LOCAL_TO_GMT)),
  429. +       asctime(LocalTime(&finfo.mtime,GMT_TO_LOCAL)),
  430.         finfo.mtime));
  431.    
  432.    send_smb(outbuf);
  433. diff -u -r --new-file last-version/source/dir.c samba-1.9.14p3/source/dir.c
  434. --- last-version/source/dir.c    Thu Sep 21 20:58:46 1995
  435. +++ samba-1.9.14p3/source/dir.c    Tue Nov  7 12:46:56 1995
  436. @@ -436,7 +436,7 @@
  437.        strcpy(filename,dname);      
  438.  
  439.        if ((strcmp(filename,mask) == 0) ||
  440. -      (name_convert(filename,dname,True,SNUM(cnum)) &&
  441. +      (name_map_mangle(filename,True,SNUM(cnum)) &&
  442.         mask_match(filename,mask,False,False)))
  443.      {
  444.        if (isrootdir && (strequal(filename,"..") || strequal(filename,".")))
  445. diff -u -r --new-file last-version/source/includes.h samba-1.9.14p3/source/includes.h
  446. --- last-version/source/includes.h    Sat Nov  4 21:51:34 1995
  447. +++ samba-1.9.14p3/source/includes.h    Tue Nov  7 12:49:21 1995
  448. @@ -84,7 +84,6 @@
  449.  #define PASSWORD_LENGTH 16
  450.  #endif
  451.  
  452. -
  453.  /* here is the general includes section - with some ifdefs generated 
  454.     by the previous section 
  455.  */
  456. @@ -755,6 +754,13 @@
  457.  end of the platform specific sections
  458.  ********************************************************************/
  459.  
  460. +#ifndef MAXINT
  461. +#define MAXINT ((((unsigned)1)<<(sizeof(int)*8-1))-1)
  462. +#endif
  463. +
  464. +#ifndef __STDC__
  465. +#define const
  466. +#endif
  467.  
  468.  /* Now for some other grungy stuff */
  469.  #ifdef NO_GETSPNAM
  470. @@ -958,6 +964,10 @@
  471.  #define F_WRLCK 0
  472.  #define F_UNLCK 0
  473.  #endif /* HAVE_FCNTL_LOCK == 0 */
  474. +
  475. +#ifdef NOSTRCASECMP
  476. +#define strcasecmp(s1,s2) StrCaseCmp(s1,s2)
  477. +#endif
  478.  
  479.  #ifndef strcpy
  480.  #define strcpy(dest,src) StrCpy(dest,src)
  481. diff -u -r --new-file last-version/source/ipc.c samba-1.9.14p3/source/ipc.c
  482. --- last-version/source/ipc.c    Sat Nov  4 18:58:24 1995
  483. +++ samba-1.9.14p3/source/ipc.c    Mon Nov  6 16:54:58 1995
  484. @@ -458,6 +458,11 @@
  485.                     struct pack_desc* desc,
  486.                     print_queue_struct* queue, int n)
  487.  {
  488. +  time_t t = queue->time;
  489. +
  490. +  /* the client expects localtime */
  491. +  t += GMT_TO_LOCAL*TimeDiff(t);
  492. +
  493.    PACKI(desc,"W",((snum%0xFF)<<8) | (queue->job%0xFF)); /* uJobId */
  494.    if (uLevel == 1) {
  495.      PACKS(desc,"B21",queue->user); /* szUserName */
  496. @@ -709,8 +714,7 @@
  497.  /****************************************************************************
  498.    get info about a share
  499.    ****************************************************************************/
  500. -
  501. -static int check_share_info(int uLevel, const char* id)
  502. +static int check_share_info(int uLevel, char* id)
  503.  {
  504.    switch( uLevel ) {
  505.    case 0:
  506. @@ -944,11 +948,13 @@
  507.    {
  508.      struct tm *t;
  509.      time_t unixdate = time(NULL);
  510. -    unixdate += GMT_TO_LOCAL*TimeDiff(unixdate);
  511. +
  512. +    put_dos_date3(p,0,unixdate); /* this is the time that is looked at by NT 
  513. +                    in a "net time" operation */
  514.  
  515. -    t = LocalTime(&unixdate,0);
  516. +    /* the client expects to get localtime, not GMT */
  517. +    t = LocalTime(&unixdate,GMT_TO_LOCAL);
  518.  
  519. -    SIVAL(p,0,unixdate); 
  520.      SIVAL(p,4,0);        /* msecs ? */
  521.      CVAL(p,8) = t->tm_hour;
  522.      CVAL(p,9) = t->tm_min;
  523. @@ -995,7 +1001,7 @@
  524.  
  525.    DEBUG(3,("Set password for <%s>\n",user));
  526.  
  527. -  if (!password_ok(user,pass1,strlen(pass1),NULL) || 
  528. +  if (!password_ok(user,pass1,strlen(pass1),NULL,False) || 
  529.        !chgpasswd(user,pass1,pass2))
  530.      SSVAL(*rparam,0,NERR_badpass);
  531.  
  532. @@ -1128,7 +1134,7 @@
  533.    or   <WWsTP> <WB21BB16B10zWWzDDz> 
  534.  ****************************************************************************/
  535.  static int check_printjob_info(struct pack_desc* desc,
  536. -                   int uLevel, const char* id)
  537. +                   int uLevel, char* id)
  538.  {
  539.    desc->subformat = NULL;
  540.    switch( uLevel ) {
  541. @@ -1766,7 +1772,7 @@
  542.  }
  543.  
  544.  static int check_printdest_info(struct pack_desc* desc,
  545. -                int uLevel, const char* id)
  546. +                int uLevel, char* id)
  547.  {
  548.    desc->subformat = NULL;
  549.    switch( uLevel ) {
  550. diff -u -r --new-file last-version/source/kanji.h samba-1.9.14p3/source/kanji.h
  551. --- last-version/source/kanji.h    Thu Sep 21 20:49:48 1995
  552. +++ samba-1.9.14p3/source/kanji.h    Tue Nov  7 11:03:48 1995
  553. @@ -27,9 +27,6 @@
  554.  #define _KANJI_H_
  555.  
  556.  #ifdef KANJI
  557. -#ifndef REPLACE_RENAME
  558. -#define REPLACE_RENAME
  559. -#endif
  560.  
  561.  /* FOR SHIFT JIS CODE */
  562.  #define is_shift_jis(c) \
  563. diff -u -r --new-file last-version/source/local.h samba-1.9.14p3/source/local.h
  564. --- last-version/source/local.h    Sun Oct 22 13:51:03 1995
  565. +++ samba-1.9.14p3/source/local.h    Sun Nov  5 12:37:52 1995
  566. @@ -140,4 +140,9 @@
  567.  
  568.  #define SMB_ALIGNMENT 1
  569.  
  570. +
  571. +/* shall we support browse requests via a FIFO to nmbd? */
  572. +#define ENABLE_FIFO 1
  573. +
  574. +
  575.  #endif
  576. diff -u -r --new-file last-version/source/mangle.c samba-1.9.14p3/source/mangle.c
  577. --- last-version/source/mangle.c    Fri Sep 15 20:34:00 1995
  578. +++ samba-1.9.14p3/source/mangle.c    Tue Nov  7 12:33:19 1995
  579. @@ -533,11 +533,8 @@
  580.  /****************************************************************************
  581.  convert a filename to DOS format. return True if successful.
  582.  ****************************************************************************/
  583. -BOOL name_convert(char *OutName,char *InName,BOOL need83,int snum)
  584. +BOOL name_map_mangle(char *OutName,BOOL need83,int snum)
  585.  {
  586. -  /* initially just copy it */
  587. -  strcpy(OutName,unix2dos_format(InName,False));
  588. -
  589.    /* apply any name mappings */
  590.    {
  591.      char *map = lp_mangled_map(snum);
  592. diff -u -r --new-file last-version/source/md4.c samba-1.9.14p3/source/md4.c
  593. --- last-version/source/md4.c    Thu Jan  1 10:00:00 1970
  594. +++ samba-1.9.14p3/source/md4.c    Tue Nov  7 12:44:48 1995
  595. @@ -0,0 +1,299 @@
  596. +#ifdef SMB_PASSWD
  597. +/*
  598. +   This code is from rfc1186. 
  599. +*/
  600. +
  601. + /*
  602. + ** ********************************************************************
  603. + ** md4.c -- Implementation of MD4 Message Digest Algorithm           **
  604. + ** Updated: 2/16/90 by Ronald L. Rivest                              **
  605. + ** (C) 1990 RSA Data Security, Inc.                                  **
  606. + ** ********************************************************************
  607. + */
  608. +
  609. + /*
  610. + ** To use MD4:
  611. + **   -- Include md4.h in your program
  612. + **   -- Declare an MDstruct MD to hold the state of the digest
  613. + **          computation.
  614. + **   -- Initialize MD using MDbegin(&MD)
  615. + **   -- For each full block (64 bytes) X you wish to process, call
  616. + **          MDupdate(&MD,X,512)
  617. + **      (512 is the number of bits in a full block.)
  618. + **   -- For the last block (less than 64 bytes) you wish to process,
  619. + **          MDupdate(&MD,X,n)
  620. + **      where n is the number of bits in the partial block. A partial
  621. + **      block terminates the computation, so every MD computation
  622. + **      should terminate by processing a partial block, even if it
  623. + **      has n = 0.
  624. + **   -- The message digest is available in MD.buffer[0] ...
  625. + **      MD.buffer[3].  (Least-significant byte of each word
  626. + **      should be output first.)
  627. + **   -- You can print out the digest using MDprint(&MD)
  628. + */
  629. +
  630. + /* Implementation notes:
  631. + ** This implementation assumes that ints are 32-bit quantities.
  632. + ** If the machine stores the least-significant byte of an int in the
  633. + ** least-addressed byte (e.g., VAX and 8086), then LOWBYTEFIRST
  634. + ** should be set to TRUE.  Otherwise (e.g., SUNS), LOWBYTEFIRST
  635. + ** should be set to FALSE.  Note that on machines with LOWBYTEFIRST
  636. + ** FALSE the routine MDupdate modifies has a side-effect on its input
  637. + ** array (the order of bytes in each word are reversed).  If this is
  638. + ** undesired a call to MDreverse(X) can reverse the bytes of X back
  639. + ** into order after each call to MDupdate.
  640. + */
  641. +
  642. +#define TRUE  1
  643. +#define FALSE 0
  644. +
  645. + /* Compile-time includes
  646. + */
  647. +
  648. +#include <stdio.h>
  649. +#include "md4.h"
  650. +
  651. +#define uchar unsigned char
  652. +#define int16 unsigned short
  653. +#define uint32 unsigned int
  654. + 
  655. +#include "byteorder.h"
  656. +
  657. + /* Compile-time declarations of MD4 "magic constants".
  658. + */
  659. +#define I0  0x67452301       /* Initial values for MD buffer */
  660. +#define I1  0xefcdab89
  661. +#define I2  0x98badcfe
  662. +#define I3  0x10325476
  663. +#define C2  013240474631     /* round 2 constant = sqrt(2) in octal */
  664. +#define C3  015666365641     /* round 3 constant = sqrt(3) in octal */
  665. + /* C2 and C3 are from Knuth, The Art of Programming, Volume 2
  666. + ** (Seminumerical Algorithms), Second Edition (1981), Addison-Wesley.
  667. + ** Table 2, page 660.
  668. + */
  669. +
  670. +#define fs1  3               /* round 1 shift amounts */
  671. +#define fs2  7
  672. +#define fs3 11
  673. +#define fs4 19
  674. +#define gs1  3               /* round 2 shift amounts */
  675. +#define gs2  5
  676. +#define gs3  9
  677. +#define gs4 13
  678. +#define hs1  3               /* round 3 shift amounts */
  679. +#define hs2  9
  680. +#define hs3 11
  681. +#define hs4 15
  682. +
  683. + /* Compile-time macro declarations for MD4.
  684. + ** Note: The "rot" operator uses the variable "tmp".
  685. + ** It assumes tmp is declared as unsigned int, so that the >>
  686. + ** operator will shift in zeros rather than extending the sign bit.
  687. + */
  688. +#define f(X,Y,Z)             ((X&Y) | ((~X)&Z))
  689. +#define g(X,Y,Z)             ((X&Y) | (X&Z) | (Y&Z))
  690. +#define h(X,Y,Z)             (X^Y^Z)
  691. +#define rot(X,S)             (tmp=X,(tmp<<S) | (tmp>>(32-S)))
  692. +#define ff(A,B,C,D,i,s)      A = rot((A + f(B,C,D) + X[i]),s)
  693. +#define gg(A,B,C,D,i,s)      A = rot((A + g(B,C,D) + X[i] + C2),s)
  694. +#define hh(A,B,C,D,i,s)      A = rot((A + h(B,C,D) + X[i] + C3),s)
  695. +
  696. + /* MDprint(MDp)
  697. + ** Print message digest buffer MDp as 32 hexadecimal digits.
  698. + ** Order is from low-order byte of buffer[0] to high-order byte of
  699. + ** buffer[3].
  700. + ** Each byte is printed with high-order hexadecimal digit first.
  701. + ** This is a user-callable routine.
  702. + */
  703. + void
  704. + MDprint(MDp)
  705. + MDptr MDp;
  706. + { int i,j;
  707. +   for (i=0;i<4;i++)
  708. +     for (j=0;j<32;j=j+8)
  709. +       printf("%02x",(MDp->buffer[i]>>j) & 0xFF);
  710. + }
  711. +
  712. + /* MDbegin(MDp)
  713. + ** Initialize message digest buffer MDp.
  714. + ** This is a user-callable routine.
  715. + */
  716. + void
  717. + MDbegin(MDp)
  718. + MDptr MDp;
  719. + { int i;
  720. +   MDp->buffer[0] = I0;
  721. +   MDp->buffer[1] = I1;
  722. +   MDp->buffer[2] = I2;
  723. +   MDp->buffer[3] = I3;
  724. +   for (i=0;i<8;i++) MDp->count[i] = 0;
  725. +   MDp->done = 0;
  726. + }
  727. +
  728. + /* MDreverse(X)
  729. + ** Reverse the byte-ordering of every int in X.
  730. + ** Assumes X is an array of 16 ints.
  731. + ** The macro revx reverses the byte-ordering of the next word of X.
  732. + */
  733. + void MDreverse(X)
  734. + unsigned int *X;
  735. + { register unsigned int t;
  736. +   register unsigned int i;
  737. +
  738. +   for(i = 0; i < 16; i++) {
  739. +      t = X[i];
  740. +      SIVAL(X,i*4,t);
  741. +    }
  742. + }
  743. +
  744. + /* MDblock(MDp,X)
  745. + ** Update message digest buffer MDp->buffer using 16-word data block X.
  746. + ** Assumes all 16 words of X are full of data.
  747. + ** Does not update MDp->count.
  748. + ** This routine is not user-callable.
  749. + */
  750. + static void
  751. + MDblock(MDp,X)
  752. + MDptr MDp;
  753. + unsigned int *X;
  754. + {
  755. +   register unsigned int tmp, A, B, C, D;
  756. +   MDreverse(X);
  757. +   A = MDp->buffer[0];
  758. +   B = MDp->buffer[1];
  759. +   C = MDp->buffer[2];
  760. +   D = MDp->buffer[3];
  761. +   /* Update the message digest buffer */
  762. +   ff(A , B , C , D ,  0 , fs1); /* Round 1 */
  763. +   ff(D , A , B , C ,  1 , fs2);
  764. +   ff(C , D , A , B ,  2 , fs3);
  765. +   ff(B , C , D , A ,  3 , fs4);
  766. +   ff(A , B , C , D ,  4 , fs1);
  767. +   ff(D , A , B , C ,  5 , fs2);
  768. +   ff(C , D , A , B ,  6 , fs3);
  769. +   ff(B , C , D , A ,  7 , fs4);
  770. +   ff(A , B , C , D ,  8 , fs1);
  771. +   ff(D , A , B , C ,  9 , fs2);
  772. +   ff(C , D , A , B , 10 , fs3);
  773. +   ff(B , C , D , A , 11 , fs4);
  774. +   ff(A , B , C , D , 12 , fs1);
  775. +   ff(D , A , B , C , 13 , fs2);
  776. +   ff(C , D , A , B , 14 , fs3);
  777. +   ff(B , C , D , A , 15 , fs4);
  778. +   gg(A , B , C , D ,  0 , gs1); /* Round 2 */
  779. +   gg(D , A , B , C ,  4 , gs2);
  780. +   gg(C , D , A , B ,  8 , gs3);
  781. +   gg(B , C , D , A , 12 , gs4);
  782. +   gg(A , B , C , D ,  1 , gs1);
  783. +   gg(D , A , B , C ,  5 , gs2);
  784. +   gg(C , D , A , B ,  9 , gs3);
  785. +   gg(B , C , D , A , 13 , gs4);
  786. +   gg(A , B , C , D ,  2 , gs1);
  787. +   gg(D , A , B , C ,  6 , gs2);
  788. +   gg(C , D , A , B , 10 , gs3);
  789. +   gg(B , C , D , A , 14 , gs4);
  790. +   gg(A , B , C , D ,  3 , gs1);
  791. +   gg(D , A , B , C ,  7 , gs2);
  792. +   gg(C , D , A , B , 11 , gs3);
  793. +   gg(B , C , D , A , 15 , gs4);
  794. +   hh(A , B , C , D ,  0 , hs1); /* Round 3 */
  795. +   hh(D , A , B , C ,  8 , hs2);
  796. +   hh(C , D , A , B ,  4 , hs3);
  797. +   hh(B , C , D , A , 12 , hs4);
  798. +   hh(A , B , C , D ,  2 , hs1);
  799. +   hh(D , A , B , C , 10 , hs2);
  800. +   hh(C , D , A , B ,  6 , hs3);
  801. +   hh(B , C , D , A , 14 , hs4);
  802. +   hh(A , B , C , D ,  1 , hs1);
  803. +   hh(D , A , B , C ,  9 , hs2);
  804. +   hh(C , D , A , B ,  5 , hs3);
  805. +   hh(B , C , D , A , 13 , hs4);
  806. +   hh(A , B , C , D ,  3 , hs1);
  807. +   hh(D , A , B , C , 11 , hs2);
  808. +   hh(C , D , A , B ,  7 , hs3);
  809. +   hh(B , C , D , A , 15 , hs4);
  810. +   MDp->buffer[0] += A;
  811. +   MDp->buffer[1] += B;
  812. +   MDp->buffer[2] += C;
  813. +   MDp->buffer[3] += D;
  814. + }
  815. +
  816. + /* MDupdate(MDp,X,count)
  817. + ** Input: MDp -- an MDptr
  818. + **        X -- a pointer to an array of unsigned characters.
  819. + **        count -- the number of bits of X to use.
  820. + **          (if not a multiple of 8, uses high bits of last byte.)
  821. + ** Update MDp using the number of bits of X given by count.
  822. + ** This is the basic input routine for an MD4 user.
  823. + ** The routine completes the MD computation when count < 512, so
  824. + ** every MD computation should end with one call to MDupdate with a
  825. + ** count less than 512.  A call with count 0 will be ignored if the
  826. + ** MD has already been terminated (done != 0), so an extra call with
  827. + ** count 0 can be given as a "courtesy close" to force termination
  828. + ** if desired.
  829. + */
  830. + void
  831. + MDupdate(MDp,X,count)
  832. + MDptr MDp;
  833. + unsigned char *X;
  834. + unsigned int count;
  835. + { unsigned int i, tmp, bit, byte, mask;
  836. +   unsigned char XX[64];
  837. +   unsigned char *p;
  838. +   /* return with no error if this is a courtesy close with count
  839. +   ** zero and MDp->done is true.
  840. +   */
  841. +   if (count == 0 && MDp->done) return;
  842. +   /* check to see if MD is already done and report error */
  843. +   if (MDp->done)
  844. +          { printf("\nError: MDupdate MD already done."); return; }
  845. +   /* Add count to MDp->count */
  846. +   tmp = count;
  847. +   p = MDp->count;
  848. +   while (tmp)
  849. +     { tmp += *p;
  850. +       *p++ = tmp;
  851. +       tmp = tmp >> 8;
  852. +     }
  853. +   /* Process data */
  854. +   if (count == 512)
  855. +     { /* Full block of data to handle */
  856. +       MDblock(MDp,(unsigned int *)X);
  857. +     }
  858. +   else if (count > 512) /* Check for count too large */
  859. +     { printf("\nError: MDupdate called with illegal count value %d."
  860. +              ,count);
  861. +       return;
  862. +     }
  863. +   else /* partial block -- must be last block so finish up */
  864. +     { /* Find out how many bytes and residual bits there are */
  865. +       byte = count >> 3;
  866. +       bit =  count & 7;
  867. +       /* Copy X into XX since we need to modify it */
  868. +       for (i=0;i<=byte;i++)   XX[i] = X[i];
  869. +       for (i=byte+1;i<64;i++) XX[i] = 0;
  870. +       /* Add padding '1' bit and low-order zeros in last byte */
  871. +       mask = 1 << (7 - bit);
  872. +       XX[byte] = (XX[byte] | mask) & ~( mask - 1);
  873. +       /* If room for bit count, finish up with this block */
  874. +       if (byte <= 55)
  875. +         { for (i=0;i<8;i++) XX[56+i] = MDp->count[i];
  876. +           MDblock(MDp,(unsigned int *)XX);
  877. +         }
  878. +       else /* need to do two blocks to finish up */
  879. +         { MDblock(MDp,(unsigned int *)XX);
  880. +           for (i=0;i<56;i++) XX[i] = 0;
  881. +           for (i=0;i<8;i++)  XX[56+i] = MDp->count[i];
  882. +           MDblock(MDp,(unsigned int *)XX);
  883. +         }
  884. +       /* Set flag saying we're done with MD computation */
  885. +       MDp->done = 1;
  886. +     }
  887. + }
  888. +
  889. + /*
  890. + ** End of md4.c
  891. + */
  892. +#else
  893. +void md4_dummy() {;}
  894. +#endif
  895. diff -u -r --new-file last-version/source/md4.h samba-1.9.14p3/source/md4.h
  896. --- last-version/source/md4.h    Thu Jan  1 10:00:00 1970
  897. +++ samba-1.9.14p3/source/md4.h    Tue Nov  7 10:50:21 1995
  898. @@ -0,0 +1,58 @@
  899. +/*
  900. +   This code is from rfc1186. 
  901. +*/
  902. +
  903. + /*
  904. + ** ********************************************************************
  905. + ** md4.h -- Header file for implementation of                        **
  906. + ** MD4 Message Digest Algorithm                                      **
  907. + ** Updated: 2/13/90 by Ronald L. Rivest                              **
  908. + ** (C) 1990 RSA Data Security, Inc.                                  **
  909. + ** ********************************************************************
  910. + */
  911. +
  912. + /* MDstruct is the data structure for a message digest computation.
  913. + */
  914. + typedef struct {
  915. +   unsigned int buffer[4]; /* Holds 4-word result of MD computation */
  916. +   unsigned char count[8]; /* Number of bits processed so far */
  917. +   unsigned int done;      /* Nonzero means MD computation finished */
  918. + } MDstruct, *MDptr;
  919. +
  920. + /* MDbegin(MD)
  921. +
  922. +
  923. +
  924. + ** Input: MD -- an MDptr
  925. + ** Initialize the MDstruct prepatory to doing a message digest
  926. + ** computation.
  927. + */
  928. + extern void MDbegin();
  929. +
  930. + /* MDupdate(MD,X,count)
  931. + ** Input: MD -- an MDptr
  932. + **        X -- a pointer to an array of unsigned characters.
  933. + **        count -- the number of bits of X to use (an unsigned int).
  934. + ** Updates MD using the first "count" bits of X.
  935. + ** The array pointed to by X is not modified.
  936. + ** If count is not a multiple of 8, MDupdate uses high bits of
  937. + ** last byte.
  938. + ** This is the basic input routine for a user.
  939. + ** The routine terminates the MD computation when count < 512, so
  940. + ** every MD computation should end with one call to MDupdate with a
  941. + ** count less than 512.  Zero is OK for a count.
  942. + */
  943. + extern void MDupdate();
  944. +
  945. + /* MDprint(MD)
  946. + ** Input: MD -- an MDptr
  947. + ** Prints message digest buffer MD as 32 hexadecimal digits.
  948. + ** Order is from low-order byte of buffer[0] to high-order byte
  949. + ** of buffer[3].
  950. + ** Each byte is printed with high-order hexadecimal digit first.
  951. + */
  952. + extern void MDprint();
  953. +
  954. + /*
  955. + ** End of md4.h
  956. + */
  957. diff -u -r --new-file last-version/source/mksmbpasswd.sh samba-1.9.14p3/source/mksmbpasswd.sh
  958. --- last-version/source/mksmbpasswd.sh    Tue Jul 11 13:41:45 1995
  959. +++ samba-1.9.14p3/source/mksmbpasswd.sh    Sun Nov  5 15:46:37 1995
  960. @@ -2,5 +2,5 @@
  961.  awk 'BEGIN {FS=":"
  962.      printf("#\n# SMB password file.\n#\n")
  963.      }
  964. -{ printf( "%s:%s:XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX:%s:%s:%s\n", $1, $3, $5, $6, $7) }
  965. +{ printf( "%s:%s:XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX:XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX:%s:%s:%s\n", $1, $3, $5, $6, $7) }
  966.  '
  967. diff -u -r --new-file last-version/source/nameserv.c samba-1.9.14p3/source/nameserv.c
  968. --- last-version/source/nameserv.c    Fri Sep 22 17:39:32 1995
  969. +++ samba-1.9.14p3/source/nameserv.c    Tue Nov  7 14:08:34 1995
  970. @@ -43,7 +43,6 @@
  971.  static int num_good_receives=0;
  972.  static pstring lookup="";
  973.  static int Client138=-1;
  974. -
  975.  enum name_sources {LMHOSTS, REGISTER, SELF, DNS};
  976.  
  977.  /* this is the structure used for the local netbios name table */
  978. @@ -493,12 +492,13 @@
  979.  /****************************************************************************
  980.  interpret a node status response
  981.  ****************************************************************************/
  982. -static void interpret_node_status(char *inbuf,char *master)
  983. +static void interpret_node_status(char *inbuf, char *master)
  984.  {
  985.    int level = master?3:0;
  986.    char *p = inbuf + 12 + name_len(inbuf+12) + 10;
  987.    int numnames = CVAL(p,0);
  988.    DEBUG(level,("received %d names\n",numnames));
  989. +
  990.    p += 1;
  991.    while (numnames--)
  992.      {
  993. @@ -508,6 +508,7 @@
  994.        StrnCpy(qname,p,15);
  995.        type = CVAL(p,15);
  996.        p += 16;
  997. +
  998.        if (p[0] & 0x80) strcat(flags,"<GROUP> ");
  999.        if (p[0] & 0x60 == 0) strcat(flags,"B ");
  1000.        if (p[0] & 0x60 == 1) strcat(flags,"P ");
  1001. @@ -649,8 +650,8 @@
  1002.  /****************************************************************************
  1003.  do a netbios name query to find someones IP
  1004.  ****************************************************************************/
  1005. -static BOOL name_query(char *name,char name_type,BOOL bcast,
  1006. -               struct in_addr to_ip,struct in_addr *ip,void (*fn)())
  1007. +static BOOL name_query(char *name, char name_type, BOOL bcast,
  1008. +               struct in_addr to_ip, struct in_addr *ip, void (*fn)())
  1009.  {
  1010.    BOOL found=False;
  1011.    pstring inbuf,outbuf;
  1012. @@ -738,7 +739,8 @@
  1013.  /****************************************************************************
  1014.  do a netbios name status to a host
  1015.  ****************************************************************************/
  1016. -static BOOL name_status(char *name,int type,struct in_addr to_ip,void (*fn)(),char *master)
  1017. +static BOOL name_status(char *name,int type,struct in_addr to_ip,void (*fn)(),
  1018. +                        char *master)
  1019.  {
  1020.    pstring inbuf,outbuf;
  1021.    static uint16 name_trn_id = 0x4262;
  1022. @@ -806,7 +808,7 @@
  1023.          if (rcode==0 && ancount==1 && qdcount==0) {
  1024.            DEBUG(fn?3:0,("Got a positive node status response from %s\n",
  1025.                  inet_ntoa(lastip)));
  1026. -          interpret_node_status(inbuf,master);
  1027. +          interpret_node_status(inbuf, master);
  1028.            return(True);
  1029.          }
  1030.          return(False);
  1031. @@ -1606,7 +1608,6 @@
  1032.    first = False;
  1033.  }
  1034.  
  1035. -
  1036.  /****************************************************************************
  1037.    process commands from the client
  1038.  ****************************************************************************/
  1039. @@ -1678,13 +1679,13 @@
  1040.  static BOOL open_sockets(BOOL isdaemon,int port)
  1041.  {
  1042.    struct hostent *hp;
  1043. -  
  1044. + 
  1045.    /* get host info */
  1046.    if ((hp = Get_Hostbyname(myhostname)) == 0) 
  1047.      {
  1048.        DEBUG(0,( "Get_Hostbyname: Unknown host. %s\n",myhostname));
  1049.        return False;
  1050. -    }
  1051. +    }   
  1052.  
  1053.    if (isdaemon)
  1054.      Client = open_socket_in(SOCK_DGRAM, port,*lookup?3:0);
  1055. @@ -1702,8 +1703,10 @@
  1056.    set_socket_options(Client138,"SO_BROADCAST");
  1057.    set_socket_options(Client,user_socket_options);
  1058.  
  1059. +
  1060. +  DEBUG(3, ("Socket opened.\n"));
  1061.    return True;
  1062. -}
  1063. +};
  1064.  
  1065.  
  1066.  /****************************************************************************
  1067. @@ -1734,7 +1737,8 @@
  1068.        Netmask = ip2;   
  1069.        } 
  1070.  
  1071. -    DEBUG(1,("Using IP %s  ",inet_ntoa(myip)));
  1072. +    DEBUG(1,("Using IP %s  ",inet_ntoa(myip))); /* core dump reported 
  1073. +                           doing this. Why?? XXXXX  */
  1074.      DEBUG(1,("broadcast %s  ",inet_ntoa(bcast_ip)));
  1075.      DEBUG(1,("netmask %s\n",inet_ntoa(Netmask)));    
  1076.  
  1077. @@ -1797,6 +1801,8 @@
  1078.  
  1079.    *lookup = *host_file = 0;
  1080.  
  1081. +  TimeInit();
  1082. +
  1083.    charset_initialise();
  1084.  
  1085.    strcpy(debugf,NMBLOGFILE);
  1086. @@ -1988,6 +1994,9 @@
  1087.      DEBUG(2,("%s becoming a daemon\n",timestring()));
  1088.      become_daemon();
  1089.    }
  1090. +
  1091. +
  1092. +  DEBUG(3,("Opening sockets\n"));
  1093.  
  1094.    if (open_sockets(is_daemon,port))
  1095.      {
  1096. diff -u -r --new-file last-version/source/nameserv.h samba-1.9.14p3/source/nameserv.h
  1097. --- last-version/source/nameserv.h    Thu Jan  1 10:00:00 1970
  1098. +++ samba-1.9.14p3/source/nameserv.h    Tue Nov  7 22:17:38 1995
  1099. @@ -0,0 +1,130 @@
  1100. +/* 
  1101. +   Unix SMB/Netbios implementation.
  1102. +   Version 1.9.
  1103. +   NBT netbios header - version 2
  1104. +   Copyright (C) Andrew Tridgell 1994-1995
  1105. +   
  1106. +   This program is free software; you can redistribute it and/or modify
  1107. +   it under the terms of the GNU General Public License as published by
  1108. +   the Free Software Foundation; either version 2 of the License, or
  1109. +   (at your option) any later version.
  1110. +   
  1111. +   This program is distributed in the hope that it will be useful,
  1112. +   but WITHOUT ANY WARRANTY; without even the implied warranty of
  1113. +   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  1114. +   GNU General Public License for more details.
  1115. +   
  1116. +   You should have received a copy of the GNU General Public License
  1117. +   along with this program; if not, write to the Free Software
  1118. +   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  1119. +   
  1120. +*/
  1121. +
  1122. +#define MAX_DGRAM_SIZE 576
  1123. +#define MIN_DGRAM_SIZE 12
  1124. +
  1125. +#define NMB_PORT 137
  1126. +#define DGRAM_PORT 138
  1127. +
  1128. +/* a netbios name structure */
  1129. +struct nmb_name {
  1130. +  char name[17];
  1131. +  char scope[64];
  1132. +  int name_type;
  1133. +};
  1134. +
  1135. +/* a resource record */
  1136. +struct res_rec {
  1137. +  struct nmb_name rr_name;
  1138. +  int rr_type;
  1139. +  int rr_class;
  1140. +  int ttl;
  1141. +  int rdlength;
  1142. +  char rdata[MAX_DGRAM_SIZE];
  1143. +};
  1144. +
  1145. +/* define a nmb packet. */
  1146. +struct nmb_packet
  1147. +{
  1148. +  struct {
  1149. +    int name_trn_id;
  1150. +    int opcode;
  1151. +    BOOL response;
  1152. +    struct {
  1153. +      BOOL bcast;
  1154. +      BOOL recursion_available;
  1155. +      BOOL recursion_desired;
  1156. +      BOOL trunc;
  1157. +      BOOL authoritative;
  1158. +    } nm_flags;
  1159. +    int rcode;
  1160. +    int qdcount;
  1161. +    int ancount;
  1162. +    int nscount;
  1163. +    int arcount;
  1164. +  } header;
  1165. +
  1166. +  struct {
  1167. +    struct nmb_name question_name;
  1168. +    int question_type;
  1169. +    int question_class;
  1170. +  } question;
  1171. +
  1172. +  struct res_rec *answers;
  1173. +  struct res_rec *nsrecs;
  1174. +  struct res_rec *additional;
  1175. +};
  1176. +
  1177. +
  1178. +/* a datagram - a simple structure at first, it would be good to parse
  1179. +   it properly later */
  1180. +struct dgram_packet {
  1181. +  struct {
  1182. +    int res;
  1183. +    int id;
  1184. +    struct in_addr ip;
  1185. +    int port;
  1186. +    int length;
  1187. +    int res2;
  1188. +    struct nmb_name source_name;
  1189. +    struct nmb_name dest_name;
  1190. +  } header;
  1191. +  int smbsize;
  1192. +  char smb_data[MAX_DGRAM_SIZE];
  1193. +};
  1194. +
  1195. +enum packet_type {NMB_PACKET, DGRAM_PACKET};
  1196. +
  1197. +/* define a structure used to queue packets. this will be a linked
  1198. + list of nmb packets */
  1199. +struct packet_struct
  1200. +{
  1201. +  struct packet_struct *next;
  1202. +  struct packet_struct *prev;
  1203. +  struct in_addr ip;
  1204. +  int port;
  1205. +  int fd;
  1206. +  time_t timestamp;
  1207. +  enum packet_type packet_type;
  1208. +  union {
  1209. +    struct nmb_packet nmb;
  1210. +    struct dgram_packet dgram;
  1211. +  } packet;
  1212. +};
  1213. +
  1214. +
  1215. +/* this defines a list of network interfaces */
  1216. +struct net_interface {
  1217. +  struct net_interface *next;
  1218. +  struct in_addr ip;
  1219. +  struct in_addr bcast;
  1220. +  struct in_addr netmask;
  1221. +};
  1222. +
  1223. +
  1224. +/* prototypes */
  1225. +void free_nmb_packet(struct nmb_packet *nmb);
  1226. +void free_packet(struct packet_struct *packet);
  1227. +struct packet_struct *read_packet(int fd,enum packet_type packet_type);
  1228. +BOOL send_packet(struct packet_struct *p);
  1229. +struct packet_struct *receive_packet(int fd,enum packet_type type,int timeout);
  1230. diff -u -r --new-file last-version/source/nameserv2.c samba-1.9.14p3/source/nameserv2.c
  1231. --- last-version/source/nameserv2.c    Thu Jan  1 10:00:00 1970
  1232. +++ samba-1.9.14p3/source/nameserv2.c    Tue Nov  7 22:37:02 1995
  1233. @@ -0,0 +1,1980 @@
  1234. +/* 
  1235. +   Unix SMB/Netbios implementation.
  1236. +   Version 1.9.
  1237. +   NBT netbios routines and daemon - version 2
  1238. +   Copyright (C) Andrew Tridgell 1994-1995
  1239. +   
  1240. +   This program is free software; you can redistribute it and/or modify
  1241. +   it under the terms of the GNU General Public License as published by
  1242. +   the Free Software Foundation; either version 2 of the License, or
  1243. +   (at your option) any later version.
  1244. +   
  1245. +   This program is distributed in the hope that it will be useful,
  1246. +   but WITHOUT ANY WARRANTY; without even the implied warranty of
  1247. +   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  1248. +   GNU General Public License for more details.
  1249. +   
  1250. +   You should have received a copy of the GNU General Public License
  1251. +   along with this program; if not, write to the Free Software
  1252. +   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  1253. +   
  1254. +*/
  1255. +
  1256. +#include "includes.h"
  1257. +#include "nameserv.h"
  1258. +
  1259. +
  1260. +static void queue_packet(struct packet_struct *packet);
  1261. +
  1262. +
  1263. +extern int DEBUGLEVEL;
  1264. +
  1265. +/* the list of network interfaces */
  1266. +struct net_interface *interfaces = NULL;
  1267. +
  1268. +extern pstring debugf;
  1269. +extern int DEBUGLEVEL;
  1270. +
  1271. +extern pstring scope;
  1272. +
  1273. +static int browse_interval = BROWSE_INTERVAL;
  1274. +
  1275. +static BOOL dns_serve = False;
  1276. +static BOOL CanRecurse = True;
  1277. +
  1278. +extern struct in_addr lastip;
  1279. +extern int lastport;
  1280. +extern struct in_addr myip;
  1281. +extern struct in_addr bcast_ip;
  1282. +extern struct in_addr Netmask;
  1283. +extern pstring myhostname;
  1284. +static pstring host_file;
  1285. +static pstring myname="";
  1286. +static pstring lookup="";
  1287. +static int ClientNMB=-1;
  1288. +static int ClientDGRAM=-1;
  1289. +enum name_sources {LMHOSTS, REGISTER, SELF, DNS};
  1290. +
  1291. +/* this is the structure used for the local netbios name table */
  1292. +typedef struct
  1293. +{
  1294. +  time_t start_time;
  1295. +  int ttl;
  1296. +  struct in_addr ip;
  1297. +  struct in_addr master_ip;
  1298. +  BOOL found_master;
  1299. +  BOOL valid;
  1300. +  BOOL isgroup;
  1301. +  BOOL unicast;
  1302. +  char name[100];
  1303. +  int type;
  1304. +  int count;  
  1305. +  enum name_sources source;
  1306. +} name_struct;
  1307. +
  1308. +
  1309. +static int num_names=0;
  1310. +static name_struct *names = NULL;
  1311. +
  1312. +#define NAMEVALID(i) names[i].valid
  1313. +#define ISGROUP(i) (names[i].isgroup)
  1314. +
  1315. +void process(void);
  1316. +
  1317. +/* are we running as a daemon ? */
  1318. +static BOOL is_daemon = False;
  1319. +
  1320. +/* machine comment */
  1321. +static pstring comment="";
  1322. +
  1323. +extern pstring user_socket_options;
  1324. +
  1325. +static void add_group_name(char *name);
  1326. +static void add_host_name(char *name,int type,struct in_addr *ip);
  1327. +static void dump_names(void);
  1328. +
  1329. +
  1330. +static BOOL got_bcast = False;
  1331. +static BOOL got_myip = False;
  1332. +static BOOL got_nmask = False;
  1333. +
  1334. +
  1335. +/****************************************************************************
  1336. +catch a sighup
  1337. +****************************************************************************/
  1338. +static int sig_hup()
  1339. +{
  1340. +  BlockSignals(True);
  1341. +
  1342. +  DEBUG(0,("Got SIGHUP - not implemented\n"));
  1343. +  dump_names();
  1344. +  if (!is_daemon)
  1345. +    exit(1);
  1346. +
  1347. +  BlockSignals(False);
  1348. +#ifndef DONT_REINSTALL_SIG
  1349. +  signal(SIGHUP,SIGNAL_CAST sig_hup);
  1350. +#endif
  1351. +  return(0);
  1352. +}
  1353. +
  1354. +/****************************************************************************
  1355. +catch a sigpipe
  1356. +****************************************************************************/
  1357. +static int sig_pipe()
  1358. +{
  1359. +  BlockSignals(True);
  1360. +
  1361. +  DEBUG(0,("Got SIGPIPE\n"));
  1362. +  if (!is_daemon)
  1363. +    exit(1);
  1364. +  BlockSignals(False);
  1365. +  return(0);
  1366. +}
  1367. +
  1368. +/****************************************************************************
  1369. +possibly continue after a fault
  1370. +****************************************************************************/
  1371. +static void fault_continue(void)
  1372. +{
  1373. +  static int errcount=0;
  1374. +
  1375. +  errcount++;
  1376. +
  1377. +  if (is_daemon && errcount<100)
  1378. +    process();
  1379. +
  1380. +  exit(1);
  1381. +}
  1382. +
  1383. +/****************************************************************************
  1384. +  true if two netbios names are equal
  1385. +****************************************************************************/
  1386. +static BOOL name_equal(char *s1,char *s2,int type1,int type2)
  1387. +{
  1388. +  char n1[20],n2[20];
  1389. +
  1390. +  if (type1 != type2) return(False);
  1391. +
  1392. +  StrnCpy(n1,s1,15);
  1393. +  StrnCpy(n2,s2,15);
  1394. +
  1395. +  trim_string(n1,NULL," ");
  1396. +  trim_string(n2,NULL," ");
  1397. +
  1398. +  return(strequal(n1,n2));
  1399. +}
  1400. +
  1401. +/****************************************************************************
  1402. +add a netbios name
  1403. +****************************************************************************/
  1404. +static int add_name(void)
  1405. +{
  1406. +  int i;
  1407. +
  1408. +  for (i=0;i<num_names;i++)
  1409. +    if (!names[i].valid)
  1410. +      break;
  1411. +
  1412. +  if (i==num_names) {
  1413. +    name_struct *n;
  1414. +    if (num_names == 0)    
  1415. +      n = (name_struct *)malloc(sizeof(name_struct));
  1416. +    else
  1417. +      n = (name_struct *)realloc(names,sizeof(name_struct)*(num_names+1));
  1418. +    if (!n) {
  1419. +      DEBUG(0,("Can't malloc more names space!\n"));
  1420. +      return(-1);
  1421. +    }
  1422. +    i = num_names;
  1423. +    num_names++;
  1424. +    names = n;
  1425. +  }
  1426. +
  1427. +  bzero(&names[i],sizeof(names[i]));
  1428. +
  1429. +  return(i);
  1430. +}
  1431. +
  1432. +/****************************************************************************
  1433. +find a name
  1434. +****************************************************************************/
  1435. +static int find_name(char *s,int type,BOOL groups)
  1436. +{
  1437. +  int i;
  1438. +  time_t t = time(NULL);
  1439. +
  1440. +  for (i=0;i<num_names;i++)
  1441. +    if (names[i].valid && (groups || !ISGROUP(i)))
  1442. +      {
  1443. +    if ((names[i].ttl > 0) && (t > (names[i].start_time + names[i].ttl)))
  1444. +      names[i].valid = False;
  1445. +    else
  1446. +      {
  1447. +        if (name_equal(s,names[i].name,type,names[i].type)) {
  1448. +          return(i);
  1449. +        }
  1450. +      }
  1451. +      }
  1452. +  return -1;
  1453. +}
  1454. +
  1455. +
  1456. +/****************************************************************************
  1457. +check names, and change any 0 IPs to myip
  1458. +****************************************************************************/
  1459. +static void check_names(void)
  1460. +{
  1461. +  int i;
  1462. +  int group_count=0;
  1463. +
  1464. +  /* add the magic __SAMBA__ name */
  1465. +  add_host_name("__SAMBA__",0x20,&myip);
  1466. +  add_host_name("__SAMBA__",0x0,&myip);
  1467. +
  1468. +  for (i=0;i<num_names;i++)
  1469. +    if (names[i].valid) {
  1470. +      if (ISGROUP(i)) group_count++;
  1471. +    }
  1472. +
  1473. +  if (group_count == 0)
  1474. +    add_group_name(WORKGROUP);
  1475. +
  1476. +
  1477. +  for (i=0;i<num_names;i++)
  1478. +    if (names[i].valid && strequal((char *)inet_ntoa(names[i].ip),"0.0.0.0"))
  1479. +      names[i].ip = (ISGROUP(i)?bcast_ip:myip);
  1480. +}
  1481. +
  1482. +
  1483. +/****************************************************************************
  1484. +dump a copy of the name table
  1485. +****************************************************************************/
  1486. +static void dump_names(void)
  1487. +{
  1488. +  int i;
  1489. +  DEBUG(3,("Dump of local name table\n"));
  1490. +  for (i=0;i<num_names;i++)
  1491. +    if (names[i].valid) {
  1492. +      DEBUG(3,("%s %s %d %s",
  1493. +           names[i].name,inet_ntoa(names[i].ip),
  1494. +           names[i].ttl,BOOLSTR(names[i].isgroup)));
  1495. +      if (names[i].found_master) 
  1496. +    DEBUG(3,(" %s",inet_ntoa(names[i].master_ip)));
  1497. +      DEBUG(3,("\n"));
  1498. +    }
  1499. +}
  1500. +
  1501. +
  1502. +/****************************************************************************
  1503. +load a netbios hosts file
  1504. +****************************************************************************/
  1505. +static void load_hosts_file(char *fname)
  1506. +{
  1507. +  int i;
  1508. +  FILE *f = fopen(fname,"r");
  1509. +  pstring line;
  1510. +  if (!f) 
  1511. +    {
  1512. +      DEBUG(2,("Not using non-existant lmhosts file %s\n",fname));
  1513. +      return;
  1514. +    }
  1515. +
  1516. +  while (!feof(f))
  1517. +    {
  1518. +      if (!fgets_slash(line,sizeof(pstring),f)) continue;
  1519. +      
  1520. +      if (*line == '#') continue;
  1521. +
  1522. +      {
  1523. +    string ip="",name="",flags="",extra="";
  1524. +    unsigned long a;
  1525. +    char *ptr;
  1526. +    int count = 0;
  1527. +    ptr = line;
  1528. +    if (next_token(&ptr,ip,NULL)) ++count;
  1529. +    if (next_token(&ptr,name,NULL)) ++count;
  1530. +    if (next_token(&ptr,flags,NULL)) ++count;
  1531. +    if (next_token(&ptr,extra,NULL)) ++count;
  1532. +
  1533. +    if (count <= 0) continue;
  1534. +
  1535. +    if (count > 0 && count < 2)
  1536. +      {
  1537. +        DEBUG(0,("Ill formed hosts line [%s]\n",line));        
  1538. +        continue;
  1539. +      }
  1540. +
  1541. +    i = add_name();
  1542. +    if (i < 0) 
  1543. +      {
  1544. +        fclose(f);
  1545. +        return;
  1546. +      }
  1547. +
  1548. +    a = interpret_addr(ip);
  1549. +    putip((char *)&names[i].ip,(char *)&a);
  1550. +
  1551. +    names[i].valid = True;
  1552. +    names[i].source = LMHOSTS;
  1553. +
  1554. +    StrnCpy(names[i].name,name,15);
  1555. +    if (strchr(flags,'G') || strchr(flags,'S'))
  1556. +      names[i].isgroup = True;
  1557. +    if (strchr(flags,'M') && !ISGROUP(i))
  1558. +      strcpy(myname,name);
  1559. +    if (strchr(flags,'U'))
  1560. +      names[i].unicast = True;
  1561. +    if (names[i].isgroup) 
  1562. +      names[i].type = 0xF0; /* hopefully invalid */
  1563. +    else
  1564. +      names[i].type = 0x20;
  1565. +      }      
  1566. +    }
  1567. +
  1568. +  fclose(f);
  1569. +}
  1570. +
  1571. +
  1572. +/****************************************************************************
  1573. +add a netbios group name
  1574. +****************************************************************************/
  1575. +static void add_group_name(char *name)
  1576. +{
  1577. +  int i = add_name();
  1578. +  if (i < 0) 
  1579. +    return;
  1580. +
  1581. +  bzero((char *)&names[i].ip,sizeof(names[i].ip));
  1582. +
  1583. +  strcpy(names[i].name,name);
  1584. +  names[i].isgroup = True;
  1585. +  names[i].valid = True;
  1586. +  names[i].type = 0xF0;
  1587. +  names[i].source = SELF;
  1588. +}
  1589. +
  1590. +/****************************************************************************
  1591. +add a host name
  1592. +****************************************************************************/
  1593. +static void add_host_name(char *name,int type,struct in_addr *ip)
  1594. +{
  1595. +  int i;
  1596. +
  1597. +  if (find_name(name,type,True) >= 0) return;
  1598. +
  1599. +  i = add_name();
  1600. +  if (i < 0) 
  1601. +    return;
  1602. +
  1603. +  names[i].ip = *ip;
  1604. +  strcpy(names[i].name,name);
  1605. +  names[i].valid = True;
  1606. +  names[i].start_time = time(NULL);
  1607. +  names[i].ttl = 0;
  1608. +  names[i].type = type;
  1609. +  names[i].source = SELF;
  1610. +}
  1611. +
  1612. +/****************************************************************************
  1613. +work out the length of a nmb message
  1614. +****************************************************************************/
  1615. +static int nmb_len(char *buf)
  1616. +{
  1617. +int i;
  1618. +int ret = 12;
  1619. +char *p = buf;
  1620. +int qdcount = RSVAL(buf,4);
  1621. +int ancount = RSVAL(buf,6);
  1622. +int nscount = RSVAL(buf,8);
  1623. +int arcount = RSVAL(buf,10);
  1624. +
  1625. +/* check for insane qdcount values? */
  1626. +if (qdcount > 100 || qdcount < 0)
  1627. +  {
  1628. +    DEBUG(6,("Invalid qdcount? qdcount=%d\n",qdcount));
  1629. +    return(0);
  1630. +  }
  1631. +
  1632. +for (i=0;i<qdcount;i++)
  1633. +  {
  1634. +    p = buf + ret;
  1635. +    ret += name_len(p) + 4;
  1636. +  }
  1637. +
  1638. +for (i=0;i<(ancount + nscount + arcount);i++)
  1639. +  {
  1640. +    int rdlength;
  1641. +    p = buf + ret;
  1642. +    ret += name_len(p) + 8;
  1643. +    p = buf + ret;
  1644. +    rdlength = RSVAL(p,0);
  1645. +    ret += rdlength + 2;
  1646. +  }
  1647. +
  1648. +return(ret);
  1649. +}
  1650. +
  1651. +/****************************************************************************
  1652. +receive a name message. timeout is in milliseconds
  1653. +****************************************************************************/
  1654. +static int receive_nmb(char *buffer,int timeout)
  1655. +{
  1656. +  int ret = read_max_udp(ClientNMB,buffer,sizeof(pstring),timeout);
  1657. +
  1658. +  if (ret < 0)
  1659. +    {
  1660. +      DEBUG(0,("No bytes from client\n"));
  1661. +      if (!is_daemon)
  1662. +    {
  1663. +      close_sockets();
  1664. +      exit(0);
  1665. +    }
  1666. +    }
  1667. +  
  1668. +  if (ret <= 1)
  1669. +    return 0;
  1670. +
  1671. +  log_in(buffer,ret);
  1672. +
  1673. +  DEBUG(3,("received packet from (%s) nmb_len=%d len=%d\n",
  1674. +    inet_ntoa(lastip),nmb_len(buffer),ret));
  1675. +
  1676. +  return(ret);
  1677. +}
  1678. +
  1679. +/****************************************************************************
  1680. +send a name message
  1681. +****************************************************************************/
  1682. +static BOOL send_nmb(char *buf, int len, struct in_addr *ip,int port)
  1683. +{
  1684. +  BOOL ret;
  1685. +  struct sockaddr_in sock_out;
  1686. +
  1687. +  /* set the address and port */
  1688. +  bzero((char *)&sock_out,sizeof(sock_out));
  1689. +  putip((char *)&sock_out.sin_addr,(char *)ip);
  1690. +  sock_out.sin_port = htons( port );
  1691. +  sock_out.sin_family = AF_INET;
  1692. +  
  1693. +  /* log the packet */
  1694. +  log_out(buf,len);
  1695. +
  1696. +  if (DEBUGLEVEL > 0)
  1697. +    DEBUG(3,("sending a packet of len %d to (%s) on port 137 of type DGRAM\n",
  1698. +      len,inet_ntoa(*ip)));
  1699. +    
  1700. +  /* send it */
  1701. +  ret = (sendto(ClientNMB,buf,len,0,(struct sockaddr *)&sock_out,sizeof(sock_out)) >= 0);
  1702. +
  1703. +  if (!ret)
  1704. +    DEBUG(0,("Send packet failed. ERRNO=%d\n",errno));
  1705. +
  1706. +  return(ret);
  1707. +}
  1708. +
  1709. +/*******************************************************************
  1710. +check if an IP is on my net
  1711. +********************************************************************/
  1712. +static BOOL is_mynet(struct in_addr ip)
  1713. +{
  1714. +  unsigned int net1,net2,nmask,subnet1,subnet2;
  1715. +
  1716. +  nmask   = *(unsigned int *)&Netmask;
  1717. +  net1    = (*(unsigned int *)&myip);
  1718. +  subnet1 = net1 & nmask;
  1719. +  net2    = (*(unsigned int *)&ip);
  1720. +  subnet2 = net2 & nmask;
  1721. +        
  1722. +  return((net1 != net2) && (subnet1 == subnet2));
  1723. +}
  1724. +
  1725. +/****************************************************************************
  1726. +interpret a node status response
  1727. +****************************************************************************/
  1728. +static void interpret_node_status(char *inbuf, char *master)
  1729. +{
  1730. +  int level = master?3:0;
  1731. +  char *p = inbuf + 12 + name_len(inbuf+12) + 10;
  1732. +  int numnames = CVAL(p,0);
  1733. +  DEBUG(level,("received %d names\n",numnames));
  1734. +
  1735. +  p += 1;
  1736. +  while (numnames--)
  1737. +    {
  1738. +      char qname[17];
  1739. +      int type;
  1740. +      fstring flags="";
  1741. +      StrnCpy(qname,p,15);
  1742. +      type = CVAL(p,15);
  1743. +      p += 16;
  1744. +
  1745. +      if (p[0] & 0x80) strcat(flags,"<GROUP> ");
  1746. +      if (p[0] & 0x60 == 0) strcat(flags,"B ");
  1747. +      if (p[0] & 0x60 == 1) strcat(flags,"P ");
  1748. +      if (p[0] & 0x60 == 2) strcat(flags,"M ");
  1749. +      if (p[0] & 0x60 == 3) strcat(flags,"_ ");
  1750. +      if (p[0] & 0x10) strcat(flags,"<DEREGISTERING> ");
  1751. +      if (p[0] & 0x08) strcat(flags,"<CONFLICT> ");
  1752. +      if (p[0] & 0x04) strcat(flags,"<ACTIVE> ");
  1753. +      if (p[0] & 0x02) strcat(flags,"<PERMANENT> ");
  1754. +
  1755. +      if (master && type == 0x1d) {
  1756. +    StrnCpy(master,qname,15);
  1757. +      }
  1758. +      
  1759. +      DEBUG(level,("\t%s (type=0x%x)\t%s\n",qname,type,flags));
  1760. +      p+=2;
  1761. +    }
  1762. +  DEBUG(level,("num_good_sends=%d num_good_receives=%d\n",
  1763. +           IVAL(p,20),IVAL(p,24)));
  1764. +}
  1765. +
  1766. +
  1767. +/****************************************************************************
  1768. +show a nmb message
  1769. +****************************************************************************/
  1770. +static void show_nmb(char *inbuf)
  1771. +{
  1772. +  int i,l;
  1773. +  int name_trn_id = RSVAL(inbuf,0);
  1774. +  int opcode = (CVAL(inbuf,2) >> 3) & 0xF;
  1775. +  int nm_flags = ((CVAL(inbuf,2) & 0x7) << 4) + (CVAL(inbuf,3)>>4);
  1776. +  int rcode = CVAL(inbuf,3) & 0xF;
  1777. +  int qdcount = RSVAL(inbuf,4);
  1778. +  int ancount = RSVAL(inbuf,6);
  1779. +  int nscount = RSVAL(inbuf,8);
  1780. +  int arcount = RSVAL(inbuf,10);
  1781. +  char name[100];
  1782. +
  1783. +  if (DEBUGLEVEL < 3) return;
  1784. +
  1785. +  DEBUG(3,("\nPACKET INTERPRETATION\n"));
  1786. +
  1787. +  if (opcode == 5 && ((nm_flags & ~1) == 0x10) && rcode == 0)
  1788. +    DEBUG(3,("NAME REGISTRATION REQUEST (%s)\n",nm_flags&1?"Broadcast":"Unicast"));
  1789. +
  1790. +  if (opcode == 5 && ((nm_flags & ~1) == 0x00) && rcode == 0)
  1791. +    DEBUG(3,("NAME OVERWRITE REQUEST AND DEMAND (%s)\n",nm_flags&1?"Broadcast":"Unicast"));
  1792. +  
  1793. +  if (opcode == 9 && ((nm_flags & ~1) == 0x00) && rcode == 0)
  1794. +    DEBUG(3,("NAME REFRESH REQUEST (%s)\n",nm_flags&1?"Broadcast":"Unicast"));
  1795. +
  1796. +  if (opcode == 8)
  1797. +    DEBUG(3,("NAME REFRESH (%s)\n",nm_flags&1?"Broadcast":"Unicast"));
  1798. +  
  1799. +  if (opcode == 5 && nm_flags == 0x58 && rcode == 0)
  1800. +    DEBUG(3,("POSITIVE NAME REGISTRATION RESPONSE\n"));
  1801. +  
  1802. +  if (opcode == 5 && nm_flags == 0x58 && rcode != 0 && rcode != 7)
  1803. +    DEBUG(3,("NEGATIVE NAME REGISTRATION RESPONSE\n"));
  1804. +  
  1805. +  if (opcode == 5 && nm_flags == 0x50 && rcode == 0)
  1806. +    DEBUG(3,("END-NODE CHALLENGE REGISTRATION RESPONSE\n"));
  1807. +  
  1808. +  if (opcode == 5 && nm_flags == 0x58 && rcode != 0 && rcode == 7)
  1809. +    DEBUG(3,("NAME CONFLICT DEMAND\n"));
  1810. +  
  1811. +  if (opcode == 6 && (nm_flags&~1) == 0x00 && rcode == 0)
  1812. +    DEBUG(3,("NAME RELEASE REQUEST & DEMAND (%s)\n",nm_flags&1?"Broadcast":"Unicast"));
  1813. +  
  1814. +  if (opcode == 6 && (nm_flags&~1) == 0x40 && rcode == 0)
  1815. +    DEBUG(3,("POSITIVE NAME RELEASE RESPONSE\n"));
  1816. +  
  1817. +  if (opcode == 6 && (nm_flags&~1) == 0x40 && rcode != 0)
  1818. +    DEBUG(3,("NEGATIVE NAME RELEASE RESPONSE\n"));
  1819. +  
  1820. +  if (opcode == 0 && (nm_flags&~1) == 0x10 && rcode == 0)
  1821. +    DEBUG(3,("NAME QUERY REQUEST (%s)\n",nm_flags&1?"Broadcast":"Unicast"));
  1822. +  
  1823. +  if (opcode == 0 && (nm_flags&~0x28) == 0x50 && rcode == 0)
  1824. +    DEBUG(3,("POSITIVE NAME QUERY RESPONSE\n"));
  1825. +  
  1826. +  if (opcode == 0 && (nm_flags&~0x08) == 0x50 && rcode != 0)
  1827. +    DEBUG(3,("NEGATIVE NAME QUERY RESPONSE\n"));
  1828. +  
  1829. +  if (opcode == 0 && nm_flags == 0x10 && rcode == 0)
  1830. +    DEBUG(3,("REDIRECT NAME QUERY RESPONSE\n"));
  1831. +
  1832. +  if (opcode == 7 && nm_flags == 0x80 && rcode == 0)
  1833. +    DEBUG(3,("WAIT FOR ACKNOWLEDGEMENT RESPONSE\n"));
  1834. +  
  1835. +  if (opcode == 0 && (nm_flags&~1) == 0x00 && rcode == 0)
  1836. +    DEBUG(3,("NODE STATUS REQUEST (%s)\n",nm_flags&1?"Broadcast":"Unicast"));
  1837. +
  1838. +  if (opcode == 0 && nm_flags == 0x40 && rcode == 0)
  1839. +    {
  1840. +      DEBUG(3,("NODE STATUS RESPONSE\n"));
  1841. +      interpret_node_status(inbuf,NULL);
  1842. +    }
  1843. +  
  1844. +  
  1845. +  DEBUG(3,("name_trn_id=0x%x\nopcode=0x%x\nnm_flags=0x%x\nrcode=0x%x\n",
  1846. +    name_trn_id,opcode,nm_flags,rcode));
  1847. +  DEBUG(3,("qdcount=%d\nancount=%d\nnscount=%d\narcount=%d\n",
  1848. +    qdcount,ancount,nscount,arcount));
  1849. +
  1850. +  l = 12;
  1851. +  for (i=0;i<qdcount;i++)
  1852. +    {
  1853. +      int type,class;
  1854. +      DEBUG(3,("QUESTION %d\n",i));
  1855. +      name_extract(inbuf,l,name);
  1856. +      l += name_len(inbuf+l);
  1857. +      type = RSVAL(inbuf+l,0);
  1858. +      class = RSVAL(inbuf+l,2);
  1859. +      l += 4;
  1860. +      DEBUG(3,("\t%s\n\ttype=0x%x\n\tclass=0x%x\n",name,type,class));
  1861. +    }
  1862. +
  1863. +  for (i=0;i<(ancount + nscount + arcount);i++)
  1864. +    {
  1865. +      int type,class,ttl,rdlength;
  1866. +      DEBUG(3,("RESOURCE %d\n",i));
  1867. +      name_extract(inbuf,l,name);
  1868. +      l += name_len(inbuf + l);
  1869. +      type = RSVAL(inbuf+l,0);
  1870. +      class = RSVAL(inbuf+l,2);
  1871. +      ttl = RIVAL(inbuf+l,4);
  1872. +      rdlength = RSVAL(inbuf+l,8);
  1873. +      l += 10 + rdlength;
  1874. +      DEBUG(3,("\t%s\n\ttype=0x%x\n\tclass=0x%x\n",name,type,class));
  1875. +      DEBUG(3,("\tttl=%d\n\trdlength=%d\n",ttl,rdlength));
  1876. +    }
  1877. +
  1878. +  DEBUG(3,("\n"));
  1879. +  
  1880. +}
  1881. +
  1882. +
  1883. +/****************************************************************************
  1884. +do a netbios name status to a host
  1885. +****************************************************************************/
  1886. +static BOOL name_status(char *name,int type,struct in_addr to_ip,char *master)
  1887. +{
  1888. +  pstring inbuf,outbuf;
  1889. +  static uint16 name_trn_id = 0x4262;
  1890. +  char *p;
  1891. +  int retries = 2;
  1892. +  int retry_time = 5000;
  1893. +  struct timeval tval;
  1894. +
  1895. +  bzero(inbuf,sizeof(inbuf));
  1896. +  bzero(outbuf,sizeof(outbuf));
  1897. +
  1898. +  name_trn_id += getpid() % 100;
  1899. +  name_trn_id = (name_trn_id % 10000);
  1900. +
  1901. +  RSSVAL(outbuf,0,name_trn_id);
  1902. +  CVAL(outbuf,2) = 0;
  1903. +  CVAL(outbuf,3) = 0x0;
  1904. +  RSSVAL(outbuf,4,1);
  1905. +  RSSVAL(outbuf,6,0);
  1906. +  RSSVAL(outbuf,8,0);
  1907. +  RSSVAL(outbuf,10,0);  
  1908. +  p = outbuf+12;
  1909. +  name_mangle(name,p,type);
  1910. +  p += name_len(p);
  1911. +  RSSVAL(p,0,0x21);
  1912. +  RSSVAL(p,2,0x1);
  1913. +  p += 4;
  1914. +
  1915. +  show_nmb(outbuf);
  1916. +
  1917. +  GetTimeOfDay(&tval);
  1918. +
  1919. +  if (!send_nmb(outbuf,nmb_len(outbuf), &to_ip, NMB_PORT))
  1920. +    return False;
  1921. +  
  1922. +  while (1)
  1923. +    {
  1924. +      struct timeval tval2;
  1925. +      GetTimeOfDay(&tval2);
  1926. +      if (TvalDiff(&tval,&tval2) > retry_time) {
  1927. +    if (!retries) break;
  1928. +    if (!send_nmb(outbuf,nmb_len(outbuf), &to_ip, NMB_PORT))
  1929. +      return False;
  1930. +    GetTimeOfDay(&tval);
  1931. +    retries--;    
  1932. +      }
  1933. +      
  1934. +      if (receive_nmb(inbuf,90))
  1935. +    {
  1936. +      int rec_name_trn_id = RSVAL(inbuf,0);
  1937. +      int rcode = CVAL(inbuf,3) & 0xF;
  1938. +      int response = (CVAL(inbuf,2)>>7);
  1939. +      int qdcount = RSVAL(inbuf,4);
  1940. +      int ancount = RSVAL(inbuf,6);
  1941. +
  1942. +      show_nmb(inbuf);
  1943. +      
  1944. +      /* is it a positive response to our request? */
  1945. +      if (response && (rec_name_trn_id == name_trn_id)) {
  1946. +        if (rcode==0 && ancount==1 && qdcount==0) {
  1947. +          interpret_node_status(inbuf, master);
  1948. +          return(True);
  1949. +        }
  1950. +        return(False);
  1951. +      }
  1952. +    }
  1953. +    }
  1954. +
  1955. +  DEBUG(0,("No status response (this is not unusual)\n"));
  1956. +
  1957. +  return(False);
  1958. +}
  1959. +
  1960. +/****************************************************************************
  1961. +construct a host announcement unicast
  1962. +****************************************************************************/
  1963. +static BOOL send_udp_dgram(char *buf,int len,
  1964. +             char *srcname,char *dstname,
  1965. +             int src_type,int dest_type,
  1966. +             struct in_addr dest_ip)
  1967. +{
  1968. +  pstring outbuf;
  1969. +  char *p,*p2;
  1970. +  static int id=0;
  1971. +  char tmp[4];
  1972. +  struct sockaddr_in sock_out;
  1973. +
  1974. +  bzero(outbuf,sizeof(outbuf));
  1975. +  RSSVAL(outbuf,0,0x1102); /* what is this? */
  1976. +  RSSVAL(outbuf,2,++id); 
  1977. +  putip(outbuf+4,(void *)&myip);
  1978. +  RSSVAL(outbuf,8,DGRAM_PORT);
  1979. +  RSSVAL(outbuf,12,0);
  1980. +  p = outbuf + 14;
  1981. +  p += name_mangle(srcname,p,src_type);
  1982. +  p += name_mangle(dstname,p,dest_type);
  1983. +
  1984. +  /* now setup the smb part */
  1985. +  p -= 4;
  1986. +  memcpy(tmp,p,4);
  1987. +  set_message(p,17,17 + len,True);
  1988. +  memcpy(p,tmp,4);
  1989. +
  1990. +  CVAL(p,smb_com) = SMBtrans;
  1991. +  SSVAL(p,smb_vwv1,len);
  1992. +  SSVAL(p,smb_vwv11,len);
  1993. +  SSVAL(p,smb_vwv12,86);
  1994. +  SSVAL(p,smb_vwv13,3);
  1995. +  SSVAL(p,smb_vwv14,1);
  1996. +  SSVAL(p,smb_vwv15,1);
  1997. +  SSVAL(p,smb_vwv16,2);
  1998. +  p2 = smb_buf(p);
  1999. +  strcpy(p2,"\\MAILSLOT\\BROWSE");
  2000. +  p2 = skip_string(p2,1);
  2001. +
  2002. +  memcpy(p2,buf,len);
  2003. +  p2 += len;
  2004. +
  2005. +  len = PTR_DIFF(p2,outbuf);
  2006. +  RSSVAL(outbuf,10,len);
  2007. +
  2008. +
  2009. +  /* set the address and port */
  2010. +  bzero((char *)&sock_out,sizeof(sock_out));
  2011. +  putip((char *)&sock_out.sin_addr,(char *)&dest_ip);
  2012. +  sock_out.sin_port = htons(DGRAM_PORT);
  2013. +  sock_out.sin_family = AF_INET;
  2014. +  
  2015. +  /* log the packet */
  2016. +  log_out(outbuf,len);
  2017. +  
  2018. +  /* send it */
  2019. +  if (sendto(ClientDGRAM,outbuf,len,0,
  2020. +         (struct sockaddr *)&sock_out,sizeof(sock_out)) < 0) {
  2021. +    DEBUG(3,("Sendto failed errno=%d (%s)\n",errno,strerror(errno)));
  2022. +    return(False);
  2023. +  } 
  2024. +
  2025. +  return(True);
  2026. +}
  2027. +
  2028. +/****************************************************************************
  2029. +construct a host announcement unicast
  2030. +****************************************************************************/
  2031. +static void announce_host(int i,char *my_name,char *Comment)
  2032. +{
  2033. +  static int announce_interval = 1;
  2034. +  char *group = names[i].name;
  2035. +  struct in_addr dest_ip = names[i].ip;
  2036. +  pstring outbuf;
  2037. +  char *p;
  2038. +
  2039. +  names[i].count++;
  2040. +
  2041. +  if ((names[i].count % announce_interval) != 0) return;
  2042. +
  2043. +  if (announce_interval < 2) announce_interval++;
  2044. +
  2045. +  DEBUG(2,("Sending host announcement to %s for group %s\n",
  2046. +       inet_ntoa(dest_ip),group));       
  2047. +
  2048. +  if (!*Comment) Comment = "NoComment";
  2049. +  if (!*my_name) my_name = "NoName";
  2050. +  if (!*group) group = "NoGroup";
  2051. +
  2052. +  if (strlen(Comment) > 47) Comment[47] = 0;  
  2053. +
  2054. +  bzero(outbuf,sizeof(outbuf));
  2055. +  p = outbuf;
  2056. +  CVAL(p,0) = 1; /* host announce */
  2057. +  SSVAL(p,1,0x6006); /* update count?? */
  2058. +  CVAL(p,3) = 0xEA; /* res1 */ 
  2059. +  SSVAL(p,4,announce_interval);
  2060. +  p += 6;
  2061. +  StrnCpy(p,my_name,16);
  2062. +  strupper(p);
  2063. +  p += 16;
  2064. +  CVAL(p,0) = 1; /* major version (was 1) */
  2065. +  CVAL(p,1) = 0x33; /* minor version (was 51) */
  2066. +  SIVAL(p,2,0xB03); /* server and w'station + unix + printq + domain member*/
  2067. +  SSVAL(p,6,0x30B); /* election version */
  2068. +  SSVAL(p,8,0xAA55); /* browse constant */
  2069. +  p += 10;
  2070. +  strcpy(p,Comment);
  2071. +  p += strlen(p)+1;
  2072. +
  2073. +  send_udp_dgram(outbuf,PTR_DIFF(p,outbuf),my_name,group,0,0x1d,dest_ip);
  2074. +}
  2075. +
  2076. +
  2077. +
  2078. +/****************************************************************************
  2079. +send a name registration packet
  2080. +****************************************************************************/
  2081. +static void send_registration(char *name,int name_type,struct in_addr dest_ip,struct in_addr ip,BOOL refresh,int ttl)
  2082. +{
  2083. +  char *p;
  2084. +  static int t = 0x176;
  2085. +  pstring outbuf;
  2086. +  bzero(outbuf,sizeof(outbuf));
  2087. +  /* send a registration request */
  2088. +  RSSVAL(outbuf,0,t++);
  2089. +  if (refresh)
  2090. +    CVAL(outbuf,2) = (0<<7) | (9<<3) | 0;
  2091. +  else
  2092. +    CVAL(outbuf,2) = (0<<7) | (5<<3) | 1;
  2093. +    
  2094. +  CVAL(outbuf,3) = (1<<4);
  2095. +  RSSVAL(outbuf,4,1);
  2096. +  RSSVAL(outbuf,6,0);
  2097. +  RSSVAL(outbuf,8,0);
  2098. +  RSSVAL(outbuf,10,1);  
  2099. +  p = outbuf+12;
  2100. +  name_mangle(name,p,name_type);
  2101. +  p += name_len(p);
  2102. +  RSSVAL(p,0,0x20);
  2103. +  RSSVAL(p,2,0x1);
  2104. +  p += 4;
  2105. +  RSSVAL(p,0,12);
  2106. +  CVAL(p,0) = CVAL(p,0) | 0xC0;
  2107. +  p += 2;
  2108. +  RSSVAL(p,0,0x20);
  2109. +  RSSVAL(p,2,0x1);
  2110. +  p += 4;  
  2111. +  RSIVAL(p,0,ttl);
  2112. +
  2113. +  RSSVAL(p,4,6);
  2114. +  RSSVAL(p,6,0);  
  2115. +  p += 8;
  2116. +  putip(p,&ip);  
  2117. +  p += 4;
  2118. +
  2119. +  DEBUG(2,("Sending a name registration request\n"));
  2120. +  if (DEBUGLEVEL > 2)
  2121. +    show_nmb(outbuf);
  2122. +
  2123. +  send_nmb(outbuf,PTR_DIFF(p,outbuf),&dest_ip,NMB_PORT);
  2124. +}
  2125. +
  2126. +/*******************************************************************
  2127. +find a master browser
  2128. +********************************************************************/
  2129. +BOOL find_master(char *name1,struct in_addr ip,struct in_addr *ipout)
  2130. +{
  2131. +  int type = 0x1d;
  2132. +  fstring name;
  2133. +  BOOL ret;
  2134. +  strcpy(name,name1);
  2135. +  if (strequal(name,"*")) {
  2136. +    strcpy(name,"\001\002__MSBROWSE__\002");
  2137. +    type = 1;
  2138. +  }
  2139. +  ret = name_query(name,type,True,False,ip,ipout);
  2140. +  if (!ret) return(False);
  2141. +  if (type != 1) return(True);
  2142. +
  2143. +  name_status(name,type,*ipout,name1);
  2144. +  return(name1[0] != '*');
  2145. +}
  2146. +
  2147. +/****************************************************************************
  2148. +process a workgroup announce frame
  2149. +****************************************************************************/
  2150. +static void process_workgroup_announce(char *group,struct in_addr ip)
  2151. +{
  2152. +  int i;
  2153. +  for (i=0;i<num_names;i++)
  2154. +    if (names[i].valid) {
  2155. +      if (names[i].name[0] == '*') {
  2156. +    StrnCpy(names[i].name,group,15);
  2157. +    names[i].master_ip = ip;
  2158. +    names[i].found_master = True;
  2159. +    names[i].count=0;
  2160. +    announce_host(i,myname,comment);
  2161. +    return;
  2162. +      }
  2163. +      if (names[i].isgroup && name_equal(names[i].name,group,0,0)) {
  2164. +    int j;
  2165. +    for (j=i;j<num_names;j++)
  2166. +      if (names[j].valid && names[j].isgroup && names[i].found_master && 
  2167. +          name_equal(names[i].name,group,0,0)) return;
  2168. +    names[i].master_ip = ip;
  2169. +    names[i].found_master = True;
  2170. +    names[i].count=0;
  2171. +    announce_host(i,myname,comment);
  2172. +    return;
  2173. +      }
  2174. +    }
  2175. +}
  2176. +
  2177. +
  2178. +/****************************************************************************
  2179. +process a browse frame
  2180. +****************************************************************************/
  2181. +static void process_browse_packet(char *buf,int len)
  2182. +{
  2183. +  char *p;
  2184. +  int command = CVAL(buf,0);
  2185. +  switch (command) {
  2186. +  case 0xc: /* workgroup announcement */
  2187. +    {
  2188. +      fstring group;
  2189. +      p = buf + 6;
  2190. +      StrnCpy(group,p,15);
  2191. +      DEBUG(2,("Got workgroup announce for %s (%s)\n",
  2192. +           group,inet_ntoa(lastip)));
  2193. +      process_workgroup_announce(group,lastip);
  2194. +      break;
  2195. +    }
  2196. +  }
  2197. +
  2198. +}
  2199. +
  2200. +/****************************************************************************
  2201. +process udp 138 datagrams
  2202. +****************************************************************************/
  2203. +static void process_dgram(void)
  2204. +{
  2205. +  pstring inbuf;
  2206. +  int len;
  2207. +  while (read_max_udp(ClientDGRAM,inbuf,sizeof(inbuf),1) > 4) {
  2208. +    char *p = inbuf;
  2209. +    len = RSVAL(inbuf,10);
  2210. +    p += 14;
  2211. +    p += name_len(p);
  2212. +    p += name_len(p);
  2213. +    p -= 4;
  2214. +    if (CVAL(p,smb_com) != SMBtrans) continue;
  2215. +    if (!strequal(smb_buf(p),"\\MAILSLOT\\BROWSE")) continue;
  2216. +    len = SVAL(p,smb_vwv11);
  2217. +    p = smb_base(p) + SVAL(p,smb_vwv12);
  2218. +    if (len <= 0) continue;
  2219. +    process_browse_packet(p,len);
  2220. +  }
  2221. +}
  2222. +
  2223. +/****************************************************************************
  2224. +a hook for registration of my own names
  2225. +****************************************************************************/
  2226. +static void do_registration_hook(void)
  2227. +{
  2228. +  static int count = 0;
  2229. +  static time_t last_t=0;
  2230. +  time_t t = time(NULL);
  2231. +  
  2232. +  if (last_t && (t-last_t)<REGISTRATION_INTERVAL) return;
  2233. +  last_t = t;
  2234. +  
  2235. +  send_registration(myname,0x20,bcast_ip,myip,count>0,300000);
  2236. +  count++;
  2237. +}
  2238. +
  2239. +/****************************************************************************
  2240. +a hook for browsing handling - called every BROWSE_INTERVAL secs
  2241. +****************************************************************************/
  2242. +static void do_browse_hook(void)
  2243. +{
  2244. +  static BOOL first = True;
  2245. +  int i;
  2246. +  static time_t last_t=0;
  2247. +  time_t t = time(NULL);
  2248. +  
  2249. +  if (last_t && (t-last_t)<browse_interval) return;
  2250. +  last_t = t;
  2251. +
  2252. +  for (i=0;i<num_names;i++)
  2253. +    {
  2254. +      BOOL old_found_master = names[i].found_master;
  2255. +
  2256. +      if (!NAMEVALID(i) || !ISGROUP(i)) continue;
  2257. +
  2258. +      if (names[i].found_master) {
  2259. +    struct in_addr ip2;
  2260. +    announce_host(i,myname,comment);
  2261. +
  2262. +    if (!name_query(names[i].name,0x1d,True,False,
  2263. +            names[i].master_ip,
  2264. +            &ip2)) {
  2265. +      DEBUG(2,("%s Master browser at %s failed to respond\n",
  2266. +           timestring(),
  2267. +           inet_ntoa(names[i].master_ip)));
  2268. +      names[i].found_master = False;
  2269. +    } else {
  2270. +      names[i].master_ip = ip2;
  2271. +    }
  2272. +      }
  2273. +
  2274. +      if (!names[i].found_master) {
  2275. +    struct in_addr ip2;
  2276. +    names[i].found_master = find_master(names[i].name,names[i].ip,&ip2);
  2277. +
  2278. +    if (names[i].found_master) {
  2279. +      names[i].master_ip = ip2;
  2280. +      DEBUG(1,("%s New master browser for %s at %s\n",
  2281. +           timestring(),
  2282. +           names[i].name,inet_ntoa(names[i].master_ip)));
  2283. +      names[i].count = 0;
  2284. +      announce_host(i,myname,comment);
  2285. +    }
  2286. +      }
  2287. +
  2288. +      if (!names[i].found_master) {
  2289. +    int level = (old_found_master||first)?1:2;
  2290. +    DEBUG(level,("%s Failed to find a master browser for %s using %s\n",
  2291. +             timestring(),
  2292. +             names[i].name,inet_ntoa(names[i].ip)));
  2293. +      }
  2294. +    }
  2295. +  first = False;
  2296. +}
  2297. +
  2298. +
  2299. +/****************************************************************************
  2300. +  do a netbios name query to find someones IP
  2301. +  ****************************************************************************/
  2302. +static BOOL name_query(char *name,int name_type, BOOL bcast,BOOL recurse,
  2303. +               struct in_addr to_ip, struct in_addr *ip)
  2304. +{
  2305. +  BOOL found=False;
  2306. +  static uint16 name_trn_id = 0;
  2307. +  int retries = 3;
  2308. +  int retry_time = bcast?250:5000;
  2309. +  struct timeval tval;
  2310. +  struct packet_struct p;
  2311. +  struct packet_struct *p2;
  2312. +  struct nmb_packet *nmb = &p.packet.nmb;
  2313. +
  2314. +  bzero((char *)&p,sizeof(p));
  2315. +
  2316. +  if (!name_trn_id) name_trn_id = (time(NULL)%0x7FFF) + (getpid()%100);
  2317. +  name_trn_id = (name_trn_id+1) % 0x7FFF;
  2318. +
  2319. +  nmb->header.name_trn_id = name_trn_id;
  2320. +  nmb->header.opcode = 0;
  2321. +  nmb->header.response = False;
  2322. +  nmb->header.nm_flags.bcast = bcast;
  2323. +  nmb->header.nm_flags.recursion_available = CanRecurse;
  2324. +  nmb->header.nm_flags.recursion_desired = recurse;
  2325. +  nmb->header.nm_flags.trunc = False;
  2326. +  nmb->header.nm_flags.authoritative = False;
  2327. +  nmb->header.rcode = 0;
  2328. +  nmb->header.qdcount = 1;
  2329. +  nmb->header.ancount = 0;
  2330. +  nmb->header.nscount = 0;
  2331. +  nmb->header.arcount = 0;
  2332. +
  2333. +  strcpy(nmb->question.question_name.name,name);
  2334. +  strupper(nmb->question.question_name.name);
  2335. +  nmb->question.question_name.name_type = name_type;
  2336. +  strcpy(nmb->question.question_name.scope,scope);
  2337. +
  2338. +  nmb->question.question_type = 0x20;
  2339. +  nmb->question.question_class = 0x1;
  2340. +
  2341. +  p.ip = to_ip;
  2342. +  p.port = NMB_PORT;
  2343. +  p.fd = ClientNMB;
  2344. +  p.timestamp = time(NULL);
  2345. +  p.packet_type = NMB_PACKET;
  2346. +
  2347. +  GetTimeOfDay(&tval);
  2348. +
  2349. +  if (!send_packet(&p)) 
  2350. +    return(False);
  2351. +
  2352. +  retries--;
  2353. +
  2354. +  while (1)
  2355. +    {
  2356. +      struct timeval tval2;
  2357. +      GetTimeOfDay(&tval2);
  2358. +      if (TvalDiff(&tval,&tval2) > retry_time) {
  2359. +    if (!retries) break;
  2360. +    if (!found && !send_packet(&p))
  2361. +      return False;
  2362. +    GetTimeOfDay(&tval);
  2363. +    retries--;
  2364. +      }
  2365. +
  2366. +      if ((p2=receive_packet(ClientNMB,NMB_PACKET,90)))
  2367. +    {     
  2368. +      struct nmb_packet *nmb2 = &p2->packet.nmb;
  2369. +      if (nmb->header.name_trn_id != nmb2->header.name_trn_id ||
  2370. +          !nmb2->header.response) {
  2371. +        /* its not for us - deal with it later */
  2372. +        queue_packet(p2);
  2373. +        continue;
  2374. +      }
  2375. +      
  2376. +      if (nmb2->header.opcode != 0 ||
  2377. +          nmb2->header.nm_flags.bcast ||
  2378. +          nmb2->header.rcode ||
  2379. +          !nmb2->header.ancount) {
  2380. +        /* XXXX what do we do with this? could be a redirect, but
  2381. +           we'll discard it for the moment */
  2382. +        free_packet(p2);
  2383. +        continue;
  2384. +      }
  2385. +
  2386. +      putip((char *)ip,&nmb2->answers->rdata[2]);
  2387. +      DEBUG(2,("Got a positive name query response from %s",
  2388. +           inet_ntoa(p2->ip)));
  2389. +      DEBUG(2,(" (%s)\n",inet_ntoa(*ip)));
  2390. +      found=True; retries=0;
  2391. +    }
  2392. +    }
  2393. +
  2394. +  return(found);
  2395. +}
  2396. +
  2397. +
  2398. +/****************************************************************************
  2399. +reply to a name release
  2400. +****************************************************************************/
  2401. +static void reply_name_release(struct packet_struct *p)
  2402. +{
  2403. +  struct nmb_packet *nmb = &p->packet.nmb;
  2404. +  char *qname = nmb->question.question_name.name;
  2405. +  BOOL wildcard = (qname[0] == '*'); 
  2406. +  int name_type = nmb->question.question_name.name_type;
  2407. +  int nb_flags = nmb->additional->rdata[0];
  2408. +  struct packet_struct p2;
  2409. +  struct nmb_packet *nmb2;
  2410. +  struct res_rec answer_rec;
  2411. +  struct in_addr ip;
  2412. +  BOOL release_ok=False;
  2413. +  int reason=5;
  2414. +  int n;
  2415. +
  2416. +  if (wildcard) return;
  2417. +
  2418. +  putip((char *)&ip,&nmb->additional->rdata[2]);  
  2419. +
  2420. +  n = find_name(qname,name_type,True);
  2421. +  if (n>=0 && names[n].source == REGISTER &&
  2422. +      !memcmp((char *)&ip,(char *)&names[n].ip,sizeof(ip))) {
  2423. +    release_ok = True;
  2424. +    names[n].valid = False;
  2425. +  }
  2426. +
  2427. +  /* Send a POSITIVE NAME RELEASE RESPONSE */
  2428. +  p2 = *p;
  2429. +  nmb2 = &p2.packet.nmb;
  2430. +
  2431. +  nmb2->header.response = True;
  2432. +  nmb2->header.nm_flags.bcast = False;
  2433. +  nmb2->header.nm_flags.recursion_available = CanRecurse;
  2434. +  nmb2->header.nm_flags.trunc = False;
  2435. +  nmb2->header.nm_flags.authoritative = True; 
  2436. +  nmb2->header.qdcount = 0;
  2437. +  nmb2->header.ancount = 1;
  2438. +  nmb2->header.nscount = 0;
  2439. +  nmb2->header.arcount = 0;
  2440. +  nmb2->header.rcode = release_ok?0:reason;
  2441. +
  2442. +  nmb2->answers = &answer_rec;
  2443. +  bzero((char *)nmb2->answers,sizeof(*nmb2->answers));
  2444. +  
  2445. +  nmb2->answers->rr_name = nmb->question.question_name;
  2446. +  nmb2->answers->rr_type = nmb->question.question_type;
  2447. +  nmb2->answers->rr_class = nmb->question.question_class;
  2448. +  nmb2->answers->ttl = 0; 
  2449. +  nmb2->answers->rdlength = 6;
  2450. +  nmb2->answers->rdata[0] = nb_flags;
  2451. +  putip(&nmb2->answers->rdata[2],(char *)&ip);
  2452. +
  2453. +  send_packet(&p2);
  2454. +}
  2455. +
  2456. +
  2457. +
  2458. +/****************************************************************************
  2459. +  reply to a reg request
  2460. +  **************************************************************************/
  2461. +static void reply_name_reg(struct packet_struct *p)
  2462. +{
  2463. +  struct nmb_packet *nmb = &p->packet.nmb;
  2464. +  char *qname = nmb->question.question_name.name;
  2465. +  BOOL wildcard = (qname[0] == '*'); 
  2466. +  BOOL bcast = nmb->header.nm_flags.bcast;
  2467. +  int name_type = nmb->question.question_name.name_type;
  2468. +  int ttl = nmb->additional->ttl;
  2469. +  int nb_flags = nmb->additional->rdata[0];
  2470. +  struct packet_struct p2;
  2471. +  struct nmb_packet *nmb2;
  2472. +  struct res_rec answer_rec;
  2473. +  struct in_addr ip;
  2474. +
  2475. +  if (wildcard) return;
  2476. +
  2477. +  putip((char *)&ip,&nmb->additional->rdata[2]);
  2478. +
  2479. +  if ((nb_flags&0x80) == 0 && (name_type != 0x1d)) {
  2480. +    int n = find_name(qname,name_type,True);
  2481. +    if (ttl==0) ttl = NMBD_MAX_TTL;
  2482. +    ttl = MIN(ttl,NMBD_MAX_TTL);
  2483. +
  2484. +    if (n>=0 && names[n].source != REGISTER && names[n].source != DNS)
  2485. +      return;
  2486. +
  2487. +    if (n<0)
  2488. +      n = add_name();
  2489. +    if (n<0) return;
  2490. +
  2491. +    bzero(&names[n],sizeof(names[n]));
  2492. +
  2493. +    StrnCpy(names[n].name,qname,15);
  2494. +    names[n].type = name_type;
  2495. +    names[n].unicast = !dns_serve || is_mynet(ip);
  2496. +    names[n].ip = ip;
  2497. +    names[n].valid = True;
  2498. +    names[n].ttl = ttl;
  2499. +    names[n].source = REGISTER;
  2500. +    names[n].start_time = p->timestamp;
  2501. +  }
  2502. +
  2503. +  if (bcast) return;
  2504. +
  2505. +  /* Send a POSITIVE NAME REGISTRATION RESPONSE */
  2506. +  /* a lot of fields get copied from the query. This gives us the IP
  2507. +     and port the reply will be sent to etc */
  2508. +  p2 = *p;
  2509. +  nmb2 = &p2.packet.nmb;
  2510. +
  2511. +  nmb2->header.response = True;
  2512. +  nmb2->header.nm_flags.bcast = False;
  2513. +  nmb2->header.nm_flags.recursion_available = CanRecurse;
  2514. +  nmb2->header.nm_flags.trunc = False;
  2515. +  nmb2->header.nm_flags.authoritative = True; 
  2516. +  nmb2->header.qdcount = 0;
  2517. +  nmb2->header.ancount = 1;
  2518. +  nmb2->header.nscount = 0;
  2519. +  nmb2->header.arcount = 0;
  2520. +
  2521. +  nmb2->answers = &answer_rec;
  2522. +  bzero((char *)nmb2->answers,sizeof(*nmb2->answers));
  2523. +  
  2524. +  nmb2->answers->rr_name = nmb->question.question_name;
  2525. +  nmb2->answers->rr_type = nmb->question.question_type;
  2526. +  nmb2->answers->rr_class = nmb->question.question_class;
  2527. +
  2528. +  /* we want them to refresh in case we die */
  2529. +  if (!ttl) ttl = 15*60;
  2530. +  ttl = MIN(ttl,15*60);
  2531. +
  2532. +  nmb2->answers->ttl = ttl; 
  2533. +  nmb2->answers->rdlength = 6;
  2534. +  nmb2->answers->rdata[0] = nb_flags;
  2535. +  putip(&nmb2->answers->rdata[2],(char *)&ip);
  2536. +
  2537. +  send_packet(&p2);  
  2538. +}
  2539. +
  2540. +
  2541. +/****************************************************************************
  2542. +reply to a name status query
  2543. +****************************************************************************/
  2544. +static void reply_name_status(struct packet_struct *p)
  2545. +{
  2546. +  struct nmb_packet *nmb = &p->packet.nmb;
  2547. +  char *qname = nmb->question.question_name.name;
  2548. +  BOOL wildcard = (qname[0] == '*'); 
  2549. +  int name_type = nmb->question.question_name.name_type;
  2550. +  struct packet_struct p2;
  2551. +  struct nmb_packet *nmb2;
  2552. +  struct res_rec answer_rec;
  2553. +  char *buf;
  2554. +  int count,i;
  2555. +
  2556. +  if (!wildcard) {
  2557. +    i = find_name(qname,name_type,False);
  2558. +
  2559. +    if (i < 0)
  2560. +      return;
  2561. +    if (names[i].source != SELF && names[i].source != LMHOSTS)
  2562. +      return;
  2563. +  }
  2564. +
  2565. +  /* Send a POSITIVE NAME STATUS RESPONSE */
  2566. +  /* a lot of fields get copied from the query. This gives us the IP
  2567. +     and port the reply will be sent to etc */
  2568. +  p2 = *p;
  2569. +  nmb2 = &p2.packet.nmb;
  2570. +
  2571. +  nmb2->header.response = True;
  2572. +  nmb2->header.nm_flags.bcast = False;
  2573. +  nmb2->header.nm_flags.recursion_available = CanRecurse;
  2574. +  nmb2->header.nm_flags.trunc = False;
  2575. +  nmb2->header.nm_flags.authoritative = True; /* WfWg ignores 
  2576. +                         non-authoritative answers */
  2577. +  nmb2->header.qdcount = 0;
  2578. +  nmb2->header.ancount = 1;
  2579. +  nmb2->header.nscount = 0;
  2580. +  nmb2->header.arcount = 0;
  2581. +
  2582. +  nmb2->answers = &answer_rec;
  2583. +  bzero((char *)nmb2->answers,sizeof(*nmb2->answers));
  2584. +  
  2585. +
  2586. +  nmb2->answers->rr_name = nmb->question.question_name;
  2587. +  nmb2->answers->rr_type = nmb->question.question_type;
  2588. +  nmb2->answers->rr_class = nmb->question.question_class;
  2589. +  nmb2->answers->ttl = 0; /* XXX what ttl to answer with? */
  2590. +
  2591. +  for (count=0,i=0;i<num_names;i++)
  2592. +    if (names[i].valid) count++;
  2593. +  count = MIN(count,400/18); /* XXXX hack, we should calculate exactly
  2594. +                how many will fit */
  2595. +
  2596. +  
  2597. +  buf = &nmb2->answers->rdata[0];
  2598. +  SCVAL(buf,0,count);
  2599. +  buf += 1;
  2600. +
  2601. +  for (i=0;i<num_names && count>0;i++)
  2602. +    if (names[i].valid)
  2603. +      {
  2604. +    bzero(buf,18);
  2605. +    strcpy(buf,names[i].name);
  2606. +    strupper(buf);
  2607. +    buf[15] = names[i].type;
  2608. +    buf += 16;
  2609. +    buf[0] = 0x4; /* active */
  2610. +    if (strequal(names[i].name,myname)) buf[0] |= 0x2; /* permanent */
  2611. +    if (ISGROUP(i)) buf[0] |= 0x80; /* group */
  2612. +    buf += 2;
  2613. +    count--;
  2614. +      }
  2615. +
  2616. +  /* we should fill in more fields of the statistics structure */
  2617. +  bzero(buf,46);
  2618. +  putip(buf,(char *)&myip);
  2619. +  {
  2620. +    extern int num_good_sends,num_good_receives;
  2621. +    SIVAL(buf,20,num_good_sends);
  2622. +    SIVAL(buf,24,num_good_receives);
  2623. +  }
  2624. +
  2625. +  buf += 46;
  2626. +
  2627. +  nmb2->answers->rdlength = PTR_DIFF(buf,&nmb2->answers->rdata[0]);
  2628. +
  2629. +  send_packet(&p2);
  2630. +}
  2631. +
  2632. +
  2633. +
  2634. +/****************************************************************************
  2635. +reply to a name query
  2636. +****************************************************************************/
  2637. +static void reply_name_query(struct packet_struct *p)
  2638. +{
  2639. +  struct nmb_packet *nmb = &p->packet.nmb;
  2640. +  char *qname = nmb->question.question_name.name;
  2641. +  BOOL wildcard = (qname[0] == '*'); 
  2642. +  BOOL bcast = nmb->header.nm_flags.bcast;
  2643. +  struct in_addr retip;
  2644. +  int name_type = nmb->question.question_name.name_type;
  2645. +  struct packet_struct p2;
  2646. +  struct nmb_packet *nmb2;
  2647. +  struct res_rec answer_rec;
  2648. +
  2649. +  if (!wildcard) {
  2650. +    int i = find_name(qname,name_type,False);
  2651. +
  2652. +    if (i < 0)
  2653. +      i = find_name(qname,name_type,True);
  2654. +    
  2655. +    if (i >= 0)
  2656. +      {
  2657. +    if (bcast && (names[i].unicast || names[i].source == REGISTER))
  2658. +      return;
  2659. +  
  2660. +    if (ISGROUP(i))
  2661. +      return;
  2662. +
  2663. +    retip = names[i].ip;
  2664. +      }
  2665. +    else
  2666. +      {
  2667. +    if ((name_type!=0 && name_type!=0x3 && name_type!=0x20) ||
  2668. +        (bcast && !dns_serve)) {
  2669. +      return;
  2670. +    } else {
  2671. +      unsigned long a;
  2672. +
  2673. +      a = interpret_addr(qname);
  2674. +      if (!a) return;
  2675. +
  2676. +      /* here is where we might recurse */      
  2677. +      putip((char *)&retip,(char *)&a);
  2678. +        
  2679. +      if (bcast && is_mynet(retip))
  2680. +        return;
  2681. +
  2682. +      i = find_name(qname,name_type,True);
  2683. +      if (i < 0) {
  2684. +        if ((i=add_name())>=0) {
  2685. +          StrnCpy(names[i].name,qname,15);
  2686. +          names[i].type = name_type;
  2687. +          names[i].unicast = is_mynet(retip);
  2688. +          names[i].ip = retip;
  2689. +          names[i].valid = True;
  2690. +          names[i].ttl = 120; /* give it two minutes */
  2691. +          names[i].start_time = p->timestamp;
  2692. +          names[i].source = DNS;        
  2693. +        }
  2694. +      }
  2695. +    }
  2696. +    DEBUG(2,(" sending positive reply (%s)\n",inet_ntoa(retip)));
  2697. +      }
  2698. +  } else {
  2699. +    retip = myip;
  2700. +  }
  2701. +  
  2702. +
  2703. +  /* a lot of fields get copied from the query. This gives us the IP
  2704. +     and port the reply will be sent to etc */
  2705. +  p2 = *p;
  2706. +  nmb2 = &p2.packet.nmb;
  2707. +
  2708. +  nmb2->header.response = True;
  2709. +  nmb2->header.nm_flags.bcast = False;
  2710. +  nmb2->header.nm_flags.recursion_available = CanRecurse;
  2711. +  nmb2->header.nm_flags.trunc = False;
  2712. +  nmb2->header.nm_flags.authoritative = True; /* WfWg ignores 
  2713. +                         non-authoritative answers */
  2714. +  nmb2->header.qdcount = 0;
  2715. +  nmb2->header.ancount = 1;
  2716. +  nmb2->header.nscount = 0;
  2717. +  nmb2->header.arcount = 0;
  2718. +
  2719. +  nmb2->answers = &answer_rec;
  2720. +  bzero((char *)nmb2->answers,sizeof(*nmb2->answers));
  2721. +
  2722. +  nmb2->answers->rr_name = nmb->question.question_name;
  2723. +  nmb2->answers->rr_type = nmb->question.question_type;
  2724. +  nmb2->answers->rr_class = nmb->question.question_class;
  2725. +  nmb2->answers->ttl = 0; /* XXX what ttl to answer with? */
  2726. +  nmb2->answers->rdlength = 6;
  2727. +  nmb2->answers->rdata[0] = 0; /* XXXX nbflags - what should this be? */
  2728. +  nmb2->answers->rdata[1] = 0; 
  2729. +  putip(&nmb2->answers->rdata[2],(char *)&retip);
  2730. +
  2731. +  send_packet(&p2);
  2732. +}
  2733. +
  2734. +
  2735. +
  2736. +/* the global packet linked-list. incoming entries are added to the
  2737. +   end of this list.  it is supposed to remain fairly short so we
  2738. +   won't bother with an end pointer. */
  2739. +static struct packet_struct *packet_queue = NULL;
  2740. +
  2741. +
  2742. +/*******************************************************************
  2743. +  queue a packet into the packet queue
  2744. +  ******************************************************************/
  2745. +static void queue_packet(struct packet_struct *packet)
  2746. +{
  2747. +  struct packet_struct *p;
  2748. +  if (!packet_queue) {
  2749. +    packet->prev = NULL;
  2750. +    packet->next = NULL;
  2751. +    packet_queue = packet;
  2752. +    return;
  2753. +  }
  2754. +  
  2755. +  /* find the bottom */
  2756. +  for (p=packet_queue;p->next;p=p->next) ;
  2757. +
  2758. +  p->next = packet;
  2759. +  packet->next = NULL;
  2760. +  packet->prev = p;
  2761. +}
  2762. +
  2763. +/****************************************************************************
  2764. +  process a nmb packet
  2765. +  ****************************************************************************/
  2766. +static void process_nmb(struct packet_struct *p)
  2767. +{
  2768. +  struct nmb_packet *nmb = &p->packet.nmb;
  2769. +
  2770. +  /* if this is a response then ignore it */
  2771. +  if (nmb->header.response) return;
  2772. +  
  2773. +  if (!nmb->header.nm_flags.bcast && 
  2774. +      nmb->header.opcode == 0x5 && 
  2775. +      nmb->header.qdcount==1 && 
  2776. +      nmb->header.arcount==1)
  2777. +    {
  2778. +      reply_name_reg(p);
  2779. +      return;
  2780. +    }
  2781. +
  2782. +  if (nmb->header.opcode==0 && 
  2783. +      nmb->header.qdcount==1)
  2784. +    {
  2785. +      switch (nmb->question.question_type)
  2786. +    {
  2787. +    case 0x20:
  2788. +      reply_name_query(p);
  2789. +      break;
  2790. +
  2791. +    case 0x21:
  2792. +      reply_name_status(p);
  2793. +      break;
  2794. +    }
  2795. +      return;
  2796. +    }
  2797. +
  2798. +  if (!nmb->header.nm_flags.bcast && 
  2799. +      nmb->header.opcode == 6 && 
  2800. +      nmb->header.qdcount==1 && 
  2801. +      nmb->header.arcount==1)
  2802. +    {
  2803. +      reply_name_release(p);
  2804. +      return;
  2805. +    }
  2806. +
  2807. +  if (!nmb->header.nm_flags.bcast && 
  2808. +      ((nmb->header.opcode == 8) || (nmb->header.opcode == 9)) && 
  2809. +      nmb->header.qdcount==1 && 
  2810. +      nmb->header.arcount==1)
  2811. +    {
  2812. +      reply_name_reg(p);
  2813. +      return;
  2814. +    }
  2815. +}
  2816. +
  2817. +
  2818. +
  2819. +/*******************************************************************
  2820. +  run elements off the packet queue till its empty
  2821. +  ******************************************************************/
  2822. +static void run_packet_queue(void)
  2823. +{
  2824. +  struct packet_struct *p;
  2825. +
  2826. +  while ((p=packet_queue)) {
  2827. +    switch (p->packet_type)
  2828. +      {
  2829. +      case NMB_PACKET:
  2830. +    process_nmb(p);
  2831. +    break;
  2832. +
  2833. +      case DGRAM_PACKET:
  2834. +    /* process_dgram(p); */
  2835. +    break;
  2836. +      }
  2837. +
  2838. +    packet_queue = packet_queue->next;
  2839. +    if (packet_queue) packet_queue->prev = NULL;
  2840. +    free_packet(p);
  2841. +  }
  2842. +}
  2843. +
  2844. +
  2845. +/****************************************************************************
  2846. +  The main select loop, listen for packets and respond
  2847. +  ***************************************************************************/
  2848. +void process(void)
  2849. +{
  2850. +  while (True)
  2851. +    {
  2852. +      fd_set fds;
  2853. +      int selrtn;
  2854. +      struct timeval timeout;
  2855. +
  2856. +      do_registration_hook();
  2857. +      do_browse_hook();
  2858. +
  2859. +      FD_ZERO(&fds);
  2860. +      FD_SET(ClientNMB,&fds);
  2861. +      FD_SET(ClientDGRAM,&fds);
  2862. +      timeout.tv_sec = NMBD_SELECT_LOOP;
  2863. +      timeout.tv_usec = 0;
  2864. +
  2865. +      selrtn = sys_select(&fds,&timeout);
  2866. +
  2867. +      if (FD_ISSET(ClientNMB,&fds)) {
  2868. +    struct packet_struct *packet = read_packet(ClientNMB,NMB_PACKET);
  2869. +    if (packet) queue_packet(packet);
  2870. +      }
  2871. +
  2872. +      if (FD_ISSET(ClientDGRAM,&fds)) {
  2873. +    struct packet_struct *packet = read_packet(ClientDGRAM,DGRAM_PACKET);
  2874. +    if (packet) queue_packet(packet);
  2875. +      }
  2876. +
  2877. +      run_packet_queue();
  2878. +    }
  2879. +}
  2880. +
  2881. +
  2882. +/****************************************************************************
  2883. +  open the socket communication
  2884. +****************************************************************************/
  2885. +static BOOL open_sockets(BOOL isdaemon,int port)
  2886. +{
  2887. +  struct hostent *hp;
  2888. + 
  2889. +  /* get host info */
  2890. +  if ((hp = Get_Hostbyname(myhostname)) == 0) 
  2891. +    {
  2892. +      DEBUG(0,( "Get_Hostbyname: Unknown host. %s\n",myhostname));
  2893. +      return False;
  2894. +    }   
  2895. +
  2896. +  if (isdaemon)
  2897. +    ClientNMB = open_socket_in(SOCK_DGRAM, port,*lookup?3:0);
  2898. +  else
  2899. +    ClientNMB = 0;
  2900. +
  2901. +  ClientDGRAM = open_socket_in(SOCK_DGRAM,DGRAM_PORT,3);
  2902. +
  2903. +  if (ClientNMB == -1)
  2904. +    return(False);
  2905. +
  2906. +  signal(SIGPIPE, SIGNAL_CAST sig_pipe);
  2907. +
  2908. +  set_socket_options(ClientNMB,"SO_BROADCAST");
  2909. +  set_socket_options(ClientDGRAM,"SO_BROADCAST");
  2910. +  set_socket_options(ClientNMB,user_socket_options);
  2911. +
  2912. +  DEBUG(3, ("Socket opened.\n"));
  2913. +  return True;
  2914. +};
  2915. +
  2916. +
  2917. +/****************************************************************************
  2918. +  initialise connect, service and file structs
  2919. +****************************************************************************/
  2920. +static BOOL init_structs(void )
  2921. +{
  2922. +  if (!get_myname(myhostname,got_myip?NULL:&myip))
  2923. +    return(False);
  2924. +
  2925. +  /* Read the broadcast address from the interface */
  2926. +  {
  2927. +    struct in_addr ip0,ip1,ip2;
  2928. +
  2929. +    ip0 = myip;
  2930. +
  2931. +    if (!(got_bcast && got_nmask))
  2932. +      {
  2933. +    get_broadcast(&ip0,&ip1,&ip2);
  2934. +
  2935. +    if (!got_myip)
  2936. +      myip = ip0;
  2937. +    
  2938. +    if (!got_bcast)
  2939. +      bcast_ip = ip1;
  2940. +    
  2941. +    if (!got_nmask)
  2942. +      Netmask = ip2;   
  2943. +      } 
  2944. +
  2945. +    DEBUG(1,("Using IP %s  ",inet_ntoa(myip))); /* core dump reported 
  2946. +                           doing this. Why?? XXXXX  */
  2947. +    DEBUG(1,("broadcast %s  ",inet_ntoa(bcast_ip)));
  2948. +    DEBUG(1,("netmask %s\n",inet_ntoa(Netmask)));    
  2949. +
  2950. +  }
  2951. +
  2952. +  if (! *myname) {
  2953. +    char *p;
  2954. +    strcpy(myname,myhostname);
  2955. +    p = strchr(myname,'.');
  2956. +    if (p) *p = 0;
  2957. +  }
  2958. +
  2959. +  add_host_name(myname,0x20,&myip);
  2960. +  add_host_name(myname,0x0,&myip);
  2961. +  add_host_name(myname,0x3,&myip);
  2962. +
  2963. +  return True;
  2964. +}
  2965. +
  2966. +/****************************************************************************
  2967. +usage on the program
  2968. +****************************************************************************/
  2969. +static void usage(char *pname)
  2970. +{
  2971. +  DEBUG(0,("Incorrect program usage - is the command line correct?\n"));
  2972. +
  2973. +  printf("Usage: %s [-n name] [-B bcast address] [-D] [-p port] [-d debuglevel] [-l log basename]\n",pname);
  2974. +  printf("Version %s\n",VERSION);
  2975. +  printf("\t-D                    become a daemon\n");
  2976. +  printf("\t-P                    passive only. don't respond\n");
  2977. +  printf("\t-R                    only reply to queries, don't actively send claims\n");
  2978. +  printf("\t-p port               listen on the specified port\n");
  2979. +  printf("\t-d debuglevel         set the debuglevel\n");
  2980. +  printf("\t-l log basename.      Basename for log/debug files\n");
  2981. +  printf("\t-n netbiosname.       the netbios name to advertise for this host\n");
  2982. +  printf("\t-B broadcast address  the address to use for broadcasts\n");
  2983. +  printf("\t-N netmask           the netmask to use for subnet determination\n");
  2984. +  printf("\t-L name              lookup this netbios name then exit\n");
  2985. +  printf("\t-S                   serve queries via DNS if not on the same subnet\n");
  2986. +  printf("\t-H hosts file        load a netbios hosts file\n");
  2987. +  printf("\t-G group name        add a group name to be part of\n");
  2988. +  printf("\t-b                   toggles browsing support (defaults to on)\n");
  2989. +  printf("\t-M group name        searches for a master browser for the given group\n");
  2990. +  printf("\t-T interval          sets the browse announcement interval in seconds\n");
  2991. +  printf("\t-C comment           sets the machine comment that appears in browse lists\n");
  2992. +  printf("\n");
  2993. +}
  2994. +
  2995. +
  2996. +/****************************************************************************
  2997. +  main program
  2998. +****************************************************************************/
  2999. +int main(int argc,char *argv[])
  3000. +{
  3001. +  int port = NMB_PORT;
  3002. +  int opt;
  3003. +  unsigned int lookup_type = 0;
  3004. +  extern FILE *dbf;
  3005. +  extern char *optarg;
  3006. +
  3007. +  *lookup = *host_file = 0;
  3008. +
  3009. +  TimeInit();
  3010. +
  3011. +  charset_initialise();
  3012. +
  3013. +  strcpy(debugf,NMBLOGFILE);
  3014. +
  3015. +#ifdef LMHOSTSFILE
  3016. +  strcpy(host_file,LMHOSTSFILE);
  3017. +#endif
  3018. +
  3019. +  /* this is for people who can't start the program correctly */
  3020. +  while (argc > 1 && (*argv[1] != '-'))
  3021. +    {
  3022. +      argv++;
  3023. +      argc--;
  3024. +    }
  3025. +
  3026. +  fault_setup(fault_continue);
  3027. +
  3028. +  signal(SIGHUP,SIGNAL_CAST sig_hup);
  3029. +
  3030. +
  3031. +  while ((opt = getopt (argc, argv, "T:O:M:I:C:bAL:i:B:N:Rn:l:d:Dp:hPSH:G:")) != EOF)
  3032. +    switch (opt)
  3033. +      {
  3034. +      case 'T':
  3035. +    browse_interval = atoi(optarg);
  3036. +    browse_interval = MAX(browse_interval,10);
  3037. +    break;
  3038. +      case 'O':
  3039. +    strcpy(user_socket_options,optarg);
  3040. +    break;
  3041. +      case 'C':
  3042. +    strcpy(comment,optarg);
  3043. +    break;
  3044. +      case 'G':
  3045. +    add_group_name(optarg);
  3046. +    break;
  3047. +      case 'A':
  3048. +    dns_serve = True;
  3049. +    break;
  3050. +      case 'H':
  3051. +    strcpy(host_file,optarg);
  3052. +    break;
  3053. +      case 'I':
  3054. +    {
  3055. +      unsigned long a = interpret_addr(optarg);
  3056. +      putip((char *)&myip,(char *)&a);
  3057. +      got_myip = True;
  3058. +    }
  3059. +    break;
  3060. +      case 'B':
  3061. +    {
  3062. +      unsigned long a = interpret_addr(optarg);
  3063. +      putip((char *)&bcast_ip,(char *)&a);
  3064. +      got_bcast = True;
  3065. +    }
  3066. +    break;
  3067. +      case 'N':
  3068. +    {
  3069. +      unsigned long a = interpret_addr(optarg);
  3070. +      putip((char *)&Netmask,(char *)&a);
  3071. +      got_nmask = True;
  3072. +    }
  3073. +    break;
  3074. +      case 'n':
  3075. +    strcpy(myname,optarg);
  3076. +    break;
  3077. +      case 'P':
  3078. +    {
  3079. +      extern BOOL passive;
  3080. +      passive = True;
  3081. +    }
  3082. +    break;
  3083. +      case 'S':
  3084. +    dns_serve = !dns_serve;
  3085. +    break;
  3086. +      case 'l':
  3087. +    sprintf(debugf,"%s.nmb",optarg);
  3088. +    break;
  3089. +      case 'i':
  3090. +    strcpy(scope,optarg);
  3091. +    strupper(scope);
  3092. +    break;
  3093. +      case 'L':
  3094. +    strcpy(lookup,optarg);
  3095. +    break;
  3096. +      case 'M':
  3097. +    if (*optarg == '-') {
  3098. +      strcpy(lookup,"\01\02__MSBROWSE__\02");
  3099. +      lookup_type = 1;
  3100. +    } else {
  3101. +      strcpy(lookup,optarg);
  3102. +      lookup_type = 0x1d;
  3103. +    }
  3104. +    break;
  3105. +      case 'D':
  3106. +    is_daemon = True;
  3107. +    break;
  3108. +      case 'd':
  3109. +    DEBUGLEVEL = atoi(optarg);
  3110. +    break;
  3111. +      case 'p':
  3112. +    port = atoi(optarg);
  3113. +    break;
  3114. +      case 'h':
  3115. +    usage(argv[0]);
  3116. +    exit(0);
  3117. +    break;
  3118. +      default:
  3119. +    usage(argv[0]);
  3120. +    exit(1);
  3121. +      }
  3122. +
  3123. +  
  3124. +  if (*lookup)
  3125. +    DEBUGLEVEL++;
  3126. +  
  3127. +  if (DEBUGLEVEL > 10)
  3128. +    {
  3129. +      extern FILE *login,*logout;
  3130. +      pstring fname;
  3131. +      sprintf(fname,"%s.in",debugf);
  3132. +      login = fopen(fname,"w"); 
  3133. +      sprintf(fname,"%s.out",debugf);
  3134. +      logout = fopen(fname,"w");
  3135. +    }
  3136. +  
  3137. +  if (*lookup)
  3138. +    {
  3139. +      if (dbf)
  3140. +    fclose(dbf);
  3141. +      dbf = stdout;
  3142. +    }
  3143. +
  3144. +  DEBUG(1,("%s netbios nameserver version %s started\n",timestring(),VERSION));
  3145. +  DEBUG(1,("Copyright Andrew Tridgell 1994\n"));
  3146. +
  3147. +  if (*host_file)
  3148. +    {
  3149. +      load_hosts_file(host_file);
  3150. +      DEBUG(3,("Loaded hosts file\n"));
  3151. +    }
  3152. +
  3153. +  init_structs();
  3154. +
  3155. +  if (*lookup) {
  3156. +    BOOL bcast = True;
  3157. +    int retries = 2;
  3158. +    char *p = strchr(lookup,'#');
  3159. +    struct in_addr ip;
  3160. +    if (p) {
  3161. +      *p = 0;
  3162. +      sscanf(p+1,"%x",&lookup_type);
  3163. +      bcast = False;
  3164. +      retries = 1;
  3165. +    }
  3166. +    if (!open_sockets(True,port)) return(1);
  3167. +    while (retries--)
  3168. +      if (name_query(lookup,lookup_type,bcast,True,bcast_ip,&ip)) {
  3169. +    printf("%s %s\n",inet_ntoa(ip),lookup);
  3170. +    name_status(lookup,lookup_type,ip,NULL);
  3171. +    return(0);
  3172. +      } 
  3173. +    printf("couldn't find name %s\n",lookup);
  3174. +    return(0);
  3175. +  }
  3176. +
  3177. +  if (!*comment)
  3178. +    strcpy(comment,"Samba %v");
  3179. +  string_sub(comment,"%v",VERSION);
  3180. +  string_sub(comment,"%h",myhostname);
  3181. +
  3182. +  check_names();
  3183. +
  3184. +  DEBUG(3,("Checked names\n"));
  3185. +  
  3186. +  dump_names();
  3187. +
  3188. +  DEBUG(3,("Dumped names\n"));
  3189. +
  3190. +  if (!is_daemon && !is_a_socket(0)) {
  3191. +    DEBUG(0,("standard input is not a socket, assuming -D option\n"));
  3192. +    is_daemon = True;
  3193. +  }
  3194. +  
  3195. +
  3196. +  if (is_daemon) {
  3197. +    DEBUG(2,("%s becoming a daemon\n",timestring()));
  3198. +    become_daemon();
  3199. +  }
  3200. +
  3201. +
  3202. +  DEBUG(3,("Opening sockets\n"));
  3203. +
  3204. +  if (open_sockets(is_daemon,port))
  3205. +    {
  3206. +      process();
  3207. +      close_sockets();
  3208. +    }
  3209. +
  3210. +  if (dbf)
  3211. +    fclose(dbf);
  3212. +  return(0);
  3213. +}
  3214. diff -u -r --new-file last-version/source/nmblib.c samba-1.9.14p3/source/nmblib.c
  3215. --- last-version/source/nmblib.c    Thu Jan  1 10:00:00 1970
  3216. +++ samba-1.9.14p3/source/nmblib.c    Tue Nov  7 22:25:10 1995
  3217. @@ -0,0 +1,504 @@
  3218. +/* 
  3219. +   Unix SMB/Netbios implementation.
  3220. +   Version 1.9.
  3221. +   NBT netbios routines and daemon - version 2
  3222. +   Copyright (C) Andrew Tridgell 1994-1995
  3223. +   
  3224. +   This program is free software; you can redistribute it and/or modify
  3225. +   it under the terms of the GNU General Public License as published by
  3226. +   the Free Software Foundation; either version 2 of the License, or
  3227. +   (at your option) any later version.
  3228. +   
  3229. +   This program is distributed in the hope that it will be useful,
  3230. +   but WITHOUT ANY WARRANTY; without even the implied warranty of
  3231. +   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  3232. +   GNU General Public License for more details.
  3233. +   
  3234. +   You should have received a copy of the GNU General Public License
  3235. +   along with this program; if not, write to the Free Software
  3236. +   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  3237. +   
  3238. +*/
  3239. +
  3240. +#include "includes.h"
  3241. +#include "nameserv.h"
  3242. +
  3243. +extern int DEBUGLEVEL;
  3244. +
  3245. +int num_good_sends=0;
  3246. +int  num_good_receives=0;
  3247. +
  3248. +/*******************************************************************
  3249. +  handle "compressed" name pointers
  3250. +  ******************************************************************/
  3251. +static BOOL handle_name_ptrs(unsigned char *ubuf,int *offset,int length,
  3252. +                 BOOL *got_pointer,int *ret)
  3253. +{
  3254. +  int loop_count=0;
  3255. +
  3256. +  while ((ubuf[*offset] & 0xC0) == 0xC0) {
  3257. +    if (!*got_pointer) (*ret) += 2;
  3258. +    (*got_pointer)=True;
  3259. +    (*offset) = ((ubuf[*offset] & ~0xC0)<<8) | ubuf[(*offset)+1];
  3260. +    if (loop_count++ == 10 || (*offset) < 0 || (*offset)>(length-2)) {
  3261. +      return(False);
  3262. +    }
  3263. +  }
  3264. +  return(True);
  3265. +}
  3266. +
  3267. +/*******************************************************************
  3268. +  parse a nmb name from "compressed" format to something readable
  3269. +  return the space taken by the name, or 0 if the name is invalid
  3270. +  ******************************************************************/
  3271. +static int parse_nmb_name(char *inbuf,int offset,int length,
  3272. +              struct nmb_name *name)
  3273. +{
  3274. +  int m,n=0;
  3275. +  unsigned char *ubuf = (unsigned char *)inbuf;
  3276. +  int ret = 0;
  3277. +  BOOL got_pointer=False;
  3278. +
  3279. +  if (length - offset < 2) return(0);  
  3280. +
  3281. +  /* handle initial name pointers */
  3282. +  if (!handle_name_ptrs(ubuf,&offset,length,&got_pointer,&ret)) return(0);
  3283. +  
  3284. +  m = ubuf[offset];
  3285. +
  3286. +  if (!m) return(0);
  3287. +  if ((m & 0xC0) || offset+m+2 > length) return(0);
  3288. +
  3289. +  bzero((char *)name,sizeof(*name));
  3290. +
  3291. +  /* the "compressed" part */
  3292. +  if (!got_pointer) ret += m + 2;
  3293. +  offset++;
  3294. +  while (m) {
  3295. +    unsigned char c1,c2;
  3296. +    c1 = ubuf[offset++]-'A';
  3297. +    c2 = ubuf[offset++]-'A';
  3298. +    if ((c1 & 0xF0) || (c2 & 0xF0)) return(0);
  3299. +    name->name[n++] = (c1<<4) | c2;
  3300. +    m -= 2;
  3301. +  }
  3302. +  name->name[n] = 0;
  3303. +
  3304. +  if (n==16) {
  3305. +    /* parse out the name type, 
  3306. +       its always in the 16th byte of the name */
  3307. +    name->name_type = name->name[15];
  3308. +  
  3309. +    /* remove trailing spaces */
  3310. +    name->name[15] = 0;
  3311. +    n = 14;
  3312. +    while (n && name->name[n]==' ') name->name[n--] = 0;  
  3313. +  }
  3314. +
  3315. +  /* now the domain parts (if any) */
  3316. +  n = 0;
  3317. +  while ((m=ubuf[offset])) {
  3318. +    /* we can have pointers within the domain part as well */
  3319. +    if (!handle_name_ptrs(ubuf,&offset,length,&got_pointer,&ret)) return(0);
  3320. +
  3321. +    if (!got_pointer) ret += m+1;
  3322. +    if (n) name->scope[n++] = '.';
  3323. +    if (m+2+offset>length || n+m+1>sizeof(name->scope)) return(0);
  3324. +    offset++;
  3325. +    while (m--) name->scope[n++] = (char)ubuf[offset++];
  3326. +  }
  3327. +  name->scope[n++] = 0;  
  3328. +
  3329. +  return(ret);
  3330. +}
  3331. +
  3332. +
  3333. +/*******************************************************************
  3334. +  put a compressed nmb name into a buffer. return the length of the
  3335. +  compressed name
  3336. +  ******************************************************************/
  3337. +static int put_nmb_name(char *buf,int offset,struct nmb_name *name)
  3338. +{
  3339. +  int ret,m;
  3340. +  char buf1[16];
  3341. +  char *p;
  3342. +
  3343. +  sprintf(buf1,"%-15.15s%c",name->name,name->name_type);
  3344. +  buf[offset] = 0x20;
  3345. +
  3346. +  ret = 34;
  3347. +
  3348. +  for (m=0;m<16;m++) {
  3349. +    buf[offset+1+2*m] = 'A' + ((buf1[m]>>4)&0xF);
  3350. +    buf[offset+2+2*m] = 'A' + (buf1[m]&0xF);
  3351. +  }
  3352. +  offset += 33;
  3353. +
  3354. +  buf[offset] = 0;
  3355. +
  3356. +  if (name->scope[0]) {
  3357. +    /* XXXX this scope handling needs testing */
  3358. +    ret += strlen(name->scope) + 1;
  3359. +    strcpy(&buf[offset+1],name->scope);  
  3360. +  
  3361. +    p = &buf[offset+1];
  3362. +    while ((p = strchr(p,'.'))) {
  3363. +      buf[offset] = PTR_DIFF(p,&buf[offset]);
  3364. +      offset += buf[offset];
  3365. +      p = &buf[offset+1];
  3366. +    }
  3367. +    buf[offset] = strlen(&buf[offset+1]);
  3368. +  }
  3369. +
  3370. +  return(ret);
  3371. +}
  3372. +
  3373. +
  3374. +/*******************************************************************
  3375. +  allocate are parse some resource records
  3376. +  ******************************************************************/
  3377. +static BOOL parse_alloc_res_rec(char *inbuf,int *offset,int length,
  3378. +                struct res_rec **recs,
  3379. +                int count)
  3380. +{
  3381. +  int i;
  3382. +  *recs = (struct res_rec *)malloc(sizeof(**recs)*count);
  3383. +  if (!*recs) return(False);
  3384. +
  3385. +  bzero(*recs,sizeof(**recs)*count);
  3386. +
  3387. +  for (i=0;i<count;i++) {
  3388. +    int l = parse_nmb_name(inbuf,*offset,length,&(*recs)[i].rr_name);
  3389. +    (*offset) += l;
  3390. +    if (!l || (*offset)+10 > length) {
  3391. +      free(*recs);
  3392. +      return(False);
  3393. +    }
  3394. +    (*recs)[i].rr_type = RSVAL(inbuf,(*offset));
  3395. +    (*recs)[i].rr_class = RSVAL(inbuf,(*offset)+2);
  3396. +    (*recs)[i].ttl = RIVAL(inbuf,(*offset)+4);
  3397. +    (*recs)[i].rdlength = RSVAL(inbuf,(*offset)+8);
  3398. +    (*offset) += 10;
  3399. +    if ((*recs)[i].rdlength>sizeof((*recs)[i].rdata) || 
  3400. +    (*offset)+(*recs)[i].rdlength > length) {
  3401. +      free(*recs);
  3402. +      return(False);
  3403. +    }
  3404. +    memcpy((*recs)[i].rdata,inbuf+(*offset),(*recs)[i].rdlength);
  3405. +    (*offset) += (*recs)[i].rdlength;    
  3406. +  }
  3407. +  return(True);
  3408. +}
  3409. +
  3410. +/*******************************************************************
  3411. +  put a resource record into a packet
  3412. +  ******************************************************************/
  3413. +static int put_res_rec(char *buf,int offset,struct res_rec *recs,int count)
  3414. +{
  3415. +  int ret=0;
  3416. +  int i;
  3417. +
  3418. +  for (i=0;i<count;i++) {
  3419. +    int l = put_nmb_name(buf,offset,&recs[i].rr_name);
  3420. +    offset += l;
  3421. +    ret += l;
  3422. +    RSSVAL(buf,offset,recs[i].rr_type);
  3423. +    RSSVAL(buf,offset+2,recs[i].rr_class);
  3424. +    RSIVAL(buf,offset+4,recs[i].ttl);
  3425. +    RSSVAL(buf,offset+8,recs[i].rdlength);
  3426. +    memcpy(buf+offset+10,recs[i].rdata,recs[i].rdlength);
  3427. +    offset += 10+recs[i].rdlength;
  3428. +    ret += 10+recs[i].rdlength;
  3429. +  }
  3430. +
  3431. +  return(ret);
  3432. +}
  3433. +
  3434. +/*******************************************************************
  3435. +  parse a dgram packet. Return False if the packet can't be parsed 
  3436. +  or is invalid for some reason, True otherwise 
  3437. +  ******************************************************************/
  3438. +static BOOL parse_dgram(char *inbuf,int length,struct dgram_packet *dgram)
  3439. +{
  3440. +  int offset;
  3441. +
  3442. +  bzero((char *)dgram,sizeof(*dgram));
  3443. +
  3444. +  if (length < 14) return(False);
  3445. +
  3446. +  dgram->header.res = RSVAL(inbuf,0);
  3447. +  dgram->header.id = RSVAL(inbuf,2);
  3448. +  putip((char *)&dgram->header.ip,inbuf+4);
  3449. +  dgram->header.port = RSVAL(inbuf,8);
  3450. +  dgram->header.length = RSVAL(inbuf,10);
  3451. +  dgram->header.res2 = RSVAL(inbuf,12);
  3452. +
  3453. +  offset = 14;
  3454. +  offset += parse_nmb_name(inbuf,offset,length,&dgram->header.source_name);
  3455. +  offset += parse_nmb_name(inbuf,offset,length,&dgram->header.dest_name);
  3456. +
  3457. +  if (offset >= length || (length-offset > sizeof(dgram->smb_data))) 
  3458. +    return(False);
  3459. +
  3460. +  dgram->smbsize = length-offset;
  3461. +  memcpy(dgram->smb_data,inbuf+offset,dgram->smbsize);
  3462. +
  3463. +  return(True);
  3464. +}
  3465. +
  3466. +
  3467. +/*******************************************************************
  3468. +  parse a nmb packet. Return False if the packet can't be parsed 
  3469. +  or is invalid for some reason, True otherwise 
  3470. +  ******************************************************************/
  3471. +static BOOL parse_nmb(char *inbuf,int length,struct nmb_packet *nmb)
  3472. +{
  3473. +  int nm_flags,offset;
  3474. +
  3475. +  bzero((char *)nmb,sizeof(*nmb));
  3476. +
  3477. +  if (length < 12) return(False);
  3478. +
  3479. +  /* parse the header */
  3480. +  nmb->header.name_trn_id = RSVAL(inbuf,0);
  3481. +  nmb->header.opcode = (CVAL(inbuf,2) >> 3) & 0xF;
  3482. +  nmb->header.response = ((CVAL(inbuf,2)>>7)&1)?True:False;
  3483. +  nm_flags = ((CVAL(inbuf,2) & 0x7) << 4) + (CVAL(inbuf,3)>>4);
  3484. +  nmb->header.nm_flags.bcast = (nm_flags&1)?True:False;
  3485. +  nmb->header.nm_flags.recursion_available = (nm_flags&8)?True:False;
  3486. +  nmb->header.nm_flags.recursion_desired = (nm_flags&0x10)?True:False;
  3487. +  nmb->header.nm_flags.trunc = (nm_flags&0x20)?True:False;
  3488. +  nmb->header.nm_flags.authoritative = (nm_flags&0x40)?True:False;
  3489. +  nmb->header.rcode = CVAL(inbuf,3) & 0xF;
  3490. +  nmb->header.qdcount = RSVAL(inbuf,4);
  3491. +  nmb->header.ancount = RSVAL(inbuf,6);
  3492. +  nmb->header.nscount = RSVAL(inbuf,8);
  3493. +  nmb->header.arcount = RSVAL(inbuf,10);
  3494. +  
  3495. +  if (nmb->header.qdcount) {
  3496. +    offset = parse_nmb_name(inbuf,12,length,&nmb->question.question_name);
  3497. +    if (!offset) return(False);
  3498. +
  3499. +    if (length - (12+offset) < 4) return(False);
  3500. +    nmb->question.question_type = RSVAL(inbuf,12+offset);
  3501. +    nmb->question.question_class = RSVAL(inbuf,12+offset+2);
  3502. +
  3503. +    offset += 12+4;
  3504. +  } else {
  3505. +    offset = 12;
  3506. +  }
  3507. +
  3508. +  /* and any resource records */
  3509. +  if (nmb->header.ancount && 
  3510. +      !parse_alloc_res_rec(inbuf,&offset,length,&nmb->answers,
  3511. +               nmb->header.ancount))
  3512. +    return(False);
  3513. +
  3514. +  if (nmb->header.nscount && 
  3515. +      !parse_alloc_res_rec(inbuf,&offset,length,&nmb->nsrecs,
  3516. +               nmb->header.nscount))
  3517. +    return(False);
  3518. +  
  3519. +  if (nmb->header.arcount && 
  3520. +      !parse_alloc_res_rec(inbuf,&offset,length,&nmb->additional,
  3521. +               nmb->header.arcount))
  3522. +    return(False);
  3523. +
  3524. +  return(True);
  3525. +}
  3526. +
  3527. +/*******************************************************************
  3528. +  free up any resources associated with an nmb packet
  3529. +  ******************************************************************/
  3530. +void free_nmb_packet(struct nmb_packet *nmb)
  3531. +{  
  3532. +  if (nmb->answers) free(nmb->answers);
  3533. +  if (nmb->nsrecs) free(nmb->nsrecs);
  3534. +  if (nmb->additional) free(nmb->additional);
  3535. +}
  3536. +
  3537. +/*******************************************************************
  3538. +  free up any resources associated with a packet
  3539. +  ******************************************************************/
  3540. +void free_packet(struct packet_struct *packet)
  3541. +{  
  3542. +  free_nmb_packet(&packet->packet.nmb);
  3543. +  free(packet);
  3544. +}
  3545. +
  3546. +/*******************************************************************
  3547. +  read a packet from a socket and parse it, returning a packet ready
  3548. +  to be used or put on the queue. This assumes a UDP socket
  3549. +  ******************************************************************/
  3550. +struct packet_struct *read_packet(int fd,enum packet_type packet_type)
  3551. +{
  3552. +  extern struct in_addr lastip;
  3553. +  extern int lastport;
  3554. +  struct packet_struct *packet;
  3555. +  char buf[MAX_DGRAM_SIZE];
  3556. +  int length;
  3557. +  BOOL ok=False;
  3558. +
  3559. +  length = read_udp_socket(fd,buf,sizeof(buf));
  3560. +  if (length < MIN_DGRAM_SIZE) return(NULL);
  3561. +
  3562. +  packet = (struct packet_struct *)malloc(sizeof(*packet));
  3563. +  if (!packet) return(NULL);
  3564. +
  3565. +  packet->next = NULL;
  3566. +  packet->prev = NULL;
  3567. +  packet->ip = lastip;
  3568. +  packet->port = lastport;
  3569. +  packet->fd = fd;
  3570. +  packet->timestamp = time(NULL);
  3571. +  packet->packet_type = packet_type;
  3572. +  switch (packet_type) 
  3573. +    {
  3574. +    case NMB_PACKET:
  3575. +      ok = parse_nmb(buf,length,&packet->packet.nmb);
  3576. +      break;
  3577. +
  3578. +    case DGRAM_PACKET:
  3579. +      ok = parse_dgram(buf,length,&packet->packet.dgram);
  3580. +      break;
  3581. +    }
  3582. +  if (!ok) {
  3583. +    free(packet);
  3584. +    return(NULL);
  3585. +  }
  3586. +
  3587. +  num_good_receives++;
  3588. +
  3589. +  return(packet);
  3590. +}
  3591. +                     
  3592. +
  3593. +/*******************************************************************
  3594. +  send a udp packet on a already open socket
  3595. +  ******************************************************************/
  3596. +static BOOL send_udp(int fd,char *buf,int len,struct in_addr *ip,int port)
  3597. +{
  3598. +  BOOL ret;
  3599. +  struct sockaddr_in sock_out;
  3600. +
  3601. +  /* set the address and port */
  3602. +  bzero((char *)&sock_out,sizeof(sock_out));
  3603. +  putip((char *)&sock_out.sin_addr,(char *)ip);
  3604. +  sock_out.sin_port = htons( port );
  3605. +  sock_out.sin_family = AF_INET;
  3606. +  
  3607. +  DEBUG(3,("sending a packet of len %d to (%s) on port 137 of type DGRAM\n",
  3608. +       len,inet_ntoa(*ip)));
  3609. +    
  3610. +  ret = (sendto(fd,buf,len,0,(struct sockaddr *)&sock_out,
  3611. +        sizeof(sock_out)) >= 0);
  3612. +
  3613. +  if (!ret)
  3614. +    DEBUG(0,("Send packet failed. ERRNO=%d\n",errno));
  3615. +
  3616. +  if (ret)
  3617. +    num_good_sends++;
  3618. +
  3619. +  return(ret);
  3620. +}
  3621. +
  3622. +
  3623. +/*******************************************************************
  3624. +  build a nmb packet ready for sending
  3625. +
  3626. +  XXXX this currently relies on not being passed something that expands
  3627. +  to a packet too big for the buffer. Eventually this should be
  3628. +  changed to set the trunc bit so the receiver can request the rest
  3629. +  via tcp (when that becomes supported)
  3630. +  ******************************************************************/
  3631. +static int build_nmb(char *buf,struct packet_struct *p)
  3632. +{
  3633. +  struct nmb_packet *nmb = &p->packet.nmb;
  3634. +  unsigned char *ubuf = (unsigned char *)buf;
  3635. +  int offset=0;
  3636. +
  3637. +  /* put in the header */
  3638. +  RSSVAL(ubuf,offset,nmb->header.name_trn_id);
  3639. +  ubuf[offset+2] = (nmb->header.opcode & 0xF) << 3;
  3640. +  if (nmb->header.response) ubuf[offset+2] |= (1<<7);
  3641. +  if (nmb->header.nm_flags.authoritative) ubuf[offset+2] |= 0x4;
  3642. +  if (nmb->header.nm_flags.trunc) ubuf[offset+2] |= 0x2;
  3643. +  if (nmb->header.nm_flags.recursion_desired) ubuf[offset+2] |= 0x1;
  3644. +  if (nmb->header.nm_flags.recursion_available) ubuf[offset+3] |= 0x80;
  3645. +  if (nmb->header.nm_flags.bcast) ubuf[offset+3] |= 0x10;
  3646. +  ubuf[offset+3] |= (nmb->header.rcode & 0xF);
  3647. +  RSSVAL(ubuf,offset+4,nmb->header.qdcount);
  3648. +  RSSVAL(ubuf,offset+6,nmb->header.ancount);
  3649. +  RSSVAL(ubuf,offset+8,nmb->header.nscount);
  3650. +  RSSVAL(ubuf,offset+10,nmb->header.arcount);
  3651. +  
  3652. +  offset += 12;
  3653. +  if (nmb->header.qdcount) {
  3654. +    /* XXXX this doesn't handle a qdcount of > 1 */
  3655. +    offset += put_nmb_name(ubuf,offset,&nmb->question.question_name);
  3656. +    RSSVAL(ubuf,offset,nmb->question.question_type);
  3657. +    RSSVAL(ubuf,offset+2,nmb->question.question_class);
  3658. +    offset += 4;
  3659. +  }
  3660. +
  3661. +  if (nmb->header.ancount)
  3662. +    offset += put_res_rec(ubuf,offset,nmb->answers,nmb->header.ancount);
  3663. +
  3664. +  if (nmb->header.nscount)
  3665. +    offset += put_res_rec(ubuf,offset,nmb->nsrecs,nmb->header.nscount);
  3666. +
  3667. +  if (nmb->header.arcount)
  3668. +    offset += put_res_rec(ubuf,offset,nmb->additional,nmb->header.arcount);  
  3669. +
  3670. +  return(offset);
  3671. +}
  3672. +
  3673. +
  3674. +/*******************************************************************
  3675. +  send a packet_struct
  3676. +  ******************************************************************/
  3677. +BOOL send_packet(struct packet_struct *p)
  3678. +{
  3679. +  char buf[1024];
  3680. +  int len=0;
  3681. +
  3682. +  bzero(buf,sizeof(buf));
  3683. +
  3684. +  switch (p->packet_type) 
  3685. +    {
  3686. +    case NMB_PACKET:
  3687. +      len = build_nmb(buf,p);
  3688. +      break;
  3689. +
  3690. +    case DGRAM_PACKET:
  3691. +      /* len = build_dgram(buf,p); */
  3692. +      break;
  3693. +    }
  3694. +
  3695. +  if (!len) return(False);
  3696. +
  3697. +  return(send_udp(p->fd,buf,len,&p->ip,p->port));
  3698. +}
  3699. +
  3700. +/****************************************************************************
  3701. +  receive a packet with timeout on a open UDP filedescriptor
  3702. +  The timeout is in milliseconds
  3703. +  ***************************************************************************/
  3704. +struct packet_struct *receive_packet(int fd,enum packet_type type,int t)
  3705. +{
  3706. +  fd_set fds;
  3707. +  struct timeval timeout;
  3708. +
  3709. +  FD_ZERO(&fds);
  3710. +  FD_SET(fd,&fds);
  3711. +  timeout.tv_sec = t/1000;
  3712. +  timeout.tv_usec = 1000*(t%1000);
  3713. +
  3714. +  sys_select(&fds,&timeout);
  3715. +
  3716. +  if (FD_ISSET(fd,&fds)) 
  3717. +    return(read_packet(fd,type));
  3718. +
  3719. +  return(NULL);
  3720. +}
  3721. +
  3722. diff -u -r --new-file last-version/source/password.c samba-1.9.14p3/source/password.c
  3723. --- last-version/source/password.c    Fri Sep 22 10:37:06 1995
  3724. +++ samba-1.9.14p3/source/password.c    Sun Nov  5 15:51:20 1995
  3725. @@ -568,7 +568,7 @@
  3726.  /****************************************************************************
  3727.  check if a username/password is OK
  3728.  ****************************************************************************/
  3729. -BOOL password_ok(char *user,char *password, int pwlen, struct passwd *pwd)
  3730. +BOOL password_ok(char *user,char *password, int pwlen, struct passwd *pwd, BOOL is_nt_password)
  3731.  {
  3732.    pstring pass2;
  3733.    int level = lp_passwordlevel();
  3734. @@ -641,6 +641,26 @@
  3735.        return(False);
  3736.      }
  3737.  
  3738. +    if(Protocol >= PROTOCOL_NT1 && is_nt_password)
  3739. +    {
  3740. +        /* We have the NT MD4 hash challenge available - see if we can
  3741. +           use it (ie. does it exist in the smbpasswd file).
  3742. +        */
  3743. +        if(smb_pass->smb_nt_passwd != NULL)
  3744. +        {
  3745. +          DEBUG(4,("Checking NT MD4 password\n"));
  3746. +          if(smb_password_check(password, smb_pass->smb_nt_passwd, challenge))
  3747. +             {
  3748. +              update_protected_database(user,True);
  3749. +            return(True);
  3750. +          }
  3751. +          DEBUG(4,("NT MD4 password check failed\n"));
  3752. +          return (False);
  3753. +        }
  3754. +    }
  3755. +
  3756. +    /* Try against the lanman password */
  3757. +
  3758.        if(smb_password_check(password, smb_pass->smb_passwd, challenge))
  3759.      {
  3760.        update_protected_database(user,True);
  3761. @@ -819,7 +839,7 @@
  3762.      while (getnetgrent(&host, &user, &domain)) {
  3763.        if (user) {
  3764.      if (user_ok(user, snum) && 
  3765. -        password_ok(user,password,pwlen,NULL)) {
  3766. +        password_ok(user,password,pwlen,NULL,False)) {
  3767.        endnetgrent();
  3768.        return(user);
  3769.      }
  3770. @@ -841,7 +861,7 @@
  3771.          static fstring name;
  3772.          strcpy(name,*member);
  3773.          if (user_ok(name,snum) &&
  3774. -        password_ok(name,password,pwlen,NULL))
  3775. +        password_ok(name,password,pwlen,NULL,False))
  3776.            return(&name[0]);
  3777.          member++;
  3778.        }
  3779. @@ -854,7 +874,7 @@
  3780.        while (pwd = getpwent ()) {
  3781.          if (*(pwd->pw_passwd) && pwd->pw_gid == gptr->gr_gid) {
  3782.            /* This Entry have PASSWORD and same GID then check pwd */
  3783. -          if (password_ok(NULL, password, pwlen, pwd)) {
  3784. +          if (password_ok(NULL, password, pwlen, pwd,False)) {
  3785.          strcpy(tm, pwd->pw_name);
  3786.          endpwent ();
  3787.          return tm;
  3788. @@ -905,14 +925,14 @@
  3789.  
  3790.        /* check the given username and password */
  3791.        if (!ok && (*user) && user_ok(user,snum)) {
  3792. -    ok = password_ok(user,password, pwlen, NULL);
  3793. +    ok = password_ok(user,password, pwlen, NULL, False);
  3794.      if (ok) DEBUG(3,("ACCEPTED: given username password ok\n"));
  3795.        }
  3796.  
  3797.        /* check for a previously registered guest username */
  3798.        if (!ok && (vuid >= 0) && validated_users[vuid].guest) {      
  3799.      if (user_ok(validated_users[vuid].name,snum) &&
  3800. -        password_ok(validated_users[vuid].name, password, pwlen, NULL)) {
  3801. +        password_ok(validated_users[vuid].name, password, pwlen, NULL, False)) {
  3802.        strcpy(user, validated_users[vuid].name);
  3803.        validated_users[vuid].guest = False;
  3804.        DEBUG(3,("ACCEPTED: given password with registered user %s\n", user));
  3805. @@ -936,7 +956,7 @@
  3806.            strcpy(user2,auser);
  3807.            if (!user_ok(user2,snum)) continue;
  3808.            
  3809. -          if (password_ok(user2,password, pwlen, NULL)) {
  3810. +          if (password_ok(user2,password, pwlen, NULL, False)) {
  3811.          ok = True;
  3812.          strcpy(user,user2);
  3813.          DEBUG(3,("ACCEPTED: session list username and given password ok\n"));
  3814. @@ -988,7 +1008,7 @@
  3815.          fstring user2;
  3816.          strcpy(user2,auser);
  3817.          if (user_ok(user2,snum) && 
  3818. -            password_ok(user2,password,pwlen,NULL))
  3819. +            password_ok(user2,password,pwlen,NULL, False))
  3820.            {
  3821.              ok = True;
  3822.              strcpy(user,user2);
  3823. diff -u -r --new-file last-version/source/printing.c samba-1.9.14p3/source/printing.c
  3824. --- last-version/source/printing.c    Thu Nov  2 09:59:36 1995
  3825. +++ samba-1.9.14p3/source/printing.c    Mon Nov  6 16:53:58 1995
  3826. @@ -83,7 +83,7 @@
  3827.         the subshell causes a "cd" to be executed.
  3828.         Only use the full path if there isn't a / preceding the %s */
  3829.      if (iOffset==0 || syscmd[iOffset-1] != '/') {
  3830. -      StrnCpy(filename,Connections[cnum].connectpath,sizeof(filename));
  3831. +      StrnCpy(filename,Connections[cnum].connectpath,sizeof(filename)-1);
  3832.        trim_string(filename,"","/");
  3833.        strcat(filename,"/");
  3834.        strcat(filename,filename1);
  3835. @@ -143,7 +143,10 @@
  3836.    lpq_reset(snum);
  3837.  }
  3838.  
  3839. +static char *Months[13] = { "Jan", "Feb", "Mar", "Apr", "May", "Jun",
  3840. +                  "Jul", "Aug", "Sep", "Oct", "Nov", "Dec", "Err"};
  3841.  
  3842. +
  3843.  /*******************************************************************
  3844.  process time fields
  3845.  ********************************************************************/
  3846. @@ -156,8 +159,6 @@
  3847.      struct tm *t;
  3848.      int i, day, hour, min, sec;
  3849.      char   *c;
  3850. -    const char *Months[13] = { "Jan", "Feb", "Mar", "Apr", "May", "Jun",
  3851. -                 "Jul", "Aug", "Sep", "Oct", "Nov", "Dec", "Err" };
  3852.  
  3853.      for (i=0; i<13; i++) if (!strncmp(tok[ptr], Months[i],3)) break; /* Find month */
  3854.      if (i<12) {
  3855. @@ -186,7 +187,6 @@
  3856.        jobtime = mktime(t);
  3857.      }
  3858.    }
  3859. -  jobtime += GMT_TO_LOCAL*TimeDiff(jobtime);
  3860.    return jobtime;
  3861.  }
  3862.  
  3863. diff -u -r --new-file last-version/source/reply.c samba-1.9.14p3/source/reply.c
  3864. --- last-version/source/reply.c    Sat Nov  4 22:32:47 1995
  3865. +++ samba-1.9.14p3/source/reply.c    Mon Nov  6 16:14:59 1995
  3866. @@ -290,6 +290,9 @@
  3867.    uint32   smb_sesskey;    
  3868.    int   smb_apasslen;   
  3869.    pstring smb_apasswd;
  3870. +  int   smb_ntpasslen = 0;   
  3871. +  pstring smb_ntpasswd;
  3872. +  BOOL valid_nt_password = False;
  3873.    pstring user;
  3874.    BOOL guest=False;
  3875.  
  3876. @@ -316,10 +319,11 @@
  3877.      if (passlen2 > 256) passlen2 = 0; /* I don't know why NT gives weird 
  3878.                      lengths sometimes */
  3879.      if(doencrypt) {
  3880. -      /* Use the lanman2 password for now until the NT md4 password
  3881. -     is worked out. */
  3882. +      /* Save the lanman2 password and the NT md4 password. */
  3883.        smb_apasslen = passlen1;
  3884.        memcpy(smb_apasswd,p,smb_apasslen);
  3885. +      smb_ntpasslen = passlen2;
  3886. +      memcpy(smb_ntpasswd,p+passlen1,smb_ntpasslen);
  3887.      } else {
  3888.        /* for Win95 */
  3889.        if (passlen1 > passlen2) {
  3890. @@ -359,8 +363,17 @@
  3891.      guest = True;
  3892.    
  3893.        /* now check if it's a valid username/password */
  3894. -      if (!guest && !password_ok(user,smb_apasswd,smb_apasslen,NULL))
  3895. +    /* If an NT password was supplied try and validate with that
  3896. +       first. This is superior as the passwords are mixed case 128 length unicode */
  3897. +    if(smb_ntpasslen && !guest)
  3898.      {
  3899. +        if(!password_ok(user,smb_ntpasswd,smb_ntpasslen,NULL,True))
  3900. +            DEBUG(0,("NT Password did not match ! Defaulting to Lanman\n"));
  3901. +        else
  3902. +            valid_nt_password = True;
  3903. +    } 
  3904. +    if (!valid_nt_password && !guest && !password_ok(user,smb_apasswd,smb_apasslen,NULL,False))
  3905. +    {
  3906.  #if !GUEST_SESSSETUP
  3907.        if (lp_security() >= SEC_USER)
  3908.          return(ERROR(ERRSRV,ERRbadpw));
  3909. @@ -456,7 +469,7 @@
  3910.    mode = SVAL(inbuf,smb_vwv0);
  3911.  
  3912.    if (check_name(name,cnum))
  3913. -    ok = directory_exist(name);
  3914. +    ok = directory_exist(name,NULL);
  3915.  
  3916.    if (!ok)
  3917.      return(ERROR(ERRDOS,ERRbadpath));
  3918. @@ -520,7 +533,7 @@
  3919.    outsize = set_message(outbuf,10,0,True);
  3920.  
  3921.    SSVAL(outbuf,smb_vwv0,mode);
  3922. -  SIVAL(outbuf,smb_vwv1,mtime + GMT_TO_LOCAL * TimeDiff(mtime));
  3923. +  put_dos_date3(outbuf,smb_vwv1,mtime);
  3924.    SIVAL(outbuf,smb_vwv3,size);
  3925.  
  3926.    if (Protocol >= PROTOCOL_NT1) {
  3927. @@ -555,14 +568,14 @@
  3928.    unix_convert(fname,cnum);
  3929.  
  3930.    mode = SVAL(inbuf,smb_vwv0);
  3931. -  mtime = IVAL(inbuf,smb_vwv1);
  3932. +  mtime = make_unix_date3(inbuf+smb_vwv1);
  3933.    
  3934. -  if (directory_exist(fname))
  3935. +  if (directory_exist(fname,NULL))
  3936.      mode |= aDIR;
  3937.    if (check_name(fname,cnum))
  3938.      ok =  (dos_chmod(cnum,fname,mode) == 0);
  3939. -  if (ok && mtime != 0)
  3940. -    ok = set_filetime(fname,mtime + LOCAL_TO_GMT * TimeDiff(mtime));
  3941. +  if (ok)
  3942. +    ok = set_filetime(fname,mtime);
  3943.    
  3944.    if (!ok)
  3945.      return(UNIXERROR(ERRDOS,ERRnoaccess));
  3946. @@ -930,7 +943,7 @@
  3947.    outsize = set_message(outbuf,7,0,True);
  3948.    SSVAL(outbuf,smb_vwv0,fnum);
  3949.    SSVAL(outbuf,smb_vwv1,fmode);
  3950. -  SIVAL(outbuf,smb_vwv2,mtime + GMT_TO_LOCAL * TimeDiff(mtime));
  3951. +  put_dos_date3(outbuf,smb_vwv2,mtime);
  3952.    SIVAL(outbuf,smb_vwv4,size);
  3953.    SSVAL(outbuf,smb_vwv6,rmode);
  3954.      
  3955. @@ -955,7 +968,7 @@
  3956.  #if 0
  3957.    int open_flags = SVAL(inbuf,smb_vwv2);
  3958.    int smb_sattr = SVAL(inbuf,smb_vwv4); 
  3959. -  uint32 smb_time = IVAL(inbuf,smb_vwv6);
  3960. +  uint32 smb_time = make_unix_date3(inbuf+smb_vwv6);
  3961.  #endif
  3962.    int smb_ofun = SVAL(inbuf,smb_vwv8);
  3963.    int unixmode;
  3964. @@ -1007,7 +1020,7 @@
  3965.    SSVAL(outbuf,smb_vwv1,(chain_size+outsize)-4);
  3966.    SSVAL(outbuf,smb_vwv2,fnum);
  3967.    SSVAL(outbuf,smb_vwv3,fmode);
  3968. -  SIVAL(outbuf,smb_vwv4,mtime + GMT_TO_LOCAL * TimeDiff(mtime));
  3969. +  put_dos_date3(outbuf,smb_vwv4,mtime);
  3970.    SIVAL(outbuf,smb_vwv6,size);
  3971.    SSVAL(outbuf,smb_vwv8,rmode);
  3972.    SSVAL(outbuf,smb_vwv11,smb_action);
  3973. @@ -1918,15 +1931,12 @@
  3974.      err = Files[fnum].wbmpx_ptr->wr_error;
  3975.    }
  3976.  
  3977. -  mtime = IVAL(inbuf,smb_vwv1);
  3978. +  mtime = make_unix_date3(inbuf+smb_vwv1);
  3979.  
  3980.    close_file(fnum);
  3981.  
  3982.    /* try and set the date */
  3983. -  if (mtime == 0 || mtime == -1)
  3984. -    DEBUG(5,("not setting null date\n"));
  3985. -  else
  3986. -    set_filetime(Files[fnum].name,mtime + LOCAL_TO_GMT * TimeDiff(mtime));
  3987. +  set_filetime(Files[fnum].name,mtime);
  3988.  
  3989.    /* We have a cached error */
  3990.    if(eclass || err)
  3991. @@ -1961,7 +1971,7 @@
  3992.  
  3993.    numtowrite = SVAL(inbuf,smb_vwv1);
  3994.    startpos = IVAL(inbuf,smb_vwv2);
  3995. -  mtime = IVAL(inbuf,smb_vwv4);
  3996. +  mtime = make_unix_date3(inbuf+smb_vwv4);
  3997.    data = smb_buf(inbuf) + 1;
  3998.    
  3999.    if (is_locked(fnum,cnum,numtowrite,startpos))
  4000. @@ -1973,10 +1983,7 @@
  4001.  
  4002.    close_file(fnum);
  4003.  
  4004. -  if (mtime == 0 || mtime == -1)
  4005. -    DEBUG(5,("not setting null date\n"));
  4006. -  else
  4007. -    set_filetime(Files[fnum].name,mtime + LOCAL_TO_GMT * TimeDiff(mtime));
  4008. +  set_filetime(Files[fnum].name,mtime);
  4009.    
  4010.    DEBUG(3,("%s writeclose fnum=%d cnum=%d num=%d wrote=%d (numopen=%d)\n",
  4011.         timestring(),fnum,cnum,numtowrite,nwritten,
  4012. @@ -2516,6 +2523,7 @@
  4013.      strcat(directory,mask);
  4014.      if (resolve_wildcards(directory,newname) && 
  4015.      can_rename(directory,cnum) && 
  4016. +    !file_exist(newname,NULL) &&
  4017.      !sys_rename(directory,newname)) count++;
  4018.      if (!count) exists = file_exist(directory,NULL);
  4019.    } else {
  4020. @@ -2545,6 +2553,7 @@
  4021.          if (!can_rename(fname,cnum)) continue;
  4022.          strcpy(destname,newname);
  4023.          if (resolve_wildcards(fname,destname) && 
  4024. +        !file_exist(destname,NULL) && 
  4025.          !sys_rename(fname,destname)) count++;
  4026.          DEBUG(3,("reply_mv : doing rename on %s -> %s\n",fname,destname));
  4027.        }
  4028. @@ -2588,7 +2597,7 @@
  4029.      ok = True;
  4030.    else
  4031.      {
  4032. -      ok = directory_exist(newdir);
  4033. +      ok = directory_exist(newdir,NULL);
  4034.        if (ok)
  4035.      string_set(&Connections[cnum].connectpath,newdir);
  4036.      }
  4037. @@ -2943,12 +2952,8 @@
  4038.    /* Convert the DOS times into unix times. Ignore create
  4039.       time as UNIX can't set this.
  4040.       */
  4041. -  
  4042. -  /* XXXX - should this include the DST offset? */
  4043. -  unix_times.actime = make_unix_date2(inbuf+smb_vwv3,False);
  4044. -  unix_times.modtime = make_unix_date2(inbuf+smb_vwv5,False);
  4045. -  unix_times.actime += LOCAL_TO_GMT*TimeDiff(unix_times.actime);
  4046. -  unix_times.modtime += LOCAL_TO_GMT*TimeDiff(unix_times.modtime);
  4047. +  unix_times.actime = make_unix_date2(inbuf+smb_vwv3);
  4048. +  unix_times.modtime = make_unix_date2(inbuf+smb_vwv5);
  4049.    
  4050.    /* Set the date on this file */
  4051.    if(sys_utime(Files[fnum].name, &unix_times))
  4052. diff -u -r --new-file last-version/source/server.c samba-1.9.14p3/source/server.c
  4053. --- last-version/source/server.c    Sat Nov  4 22:11:05 1995
  4054. +++ samba-1.9.14p3/source/server.c    Tue Nov  7 18:24:54 1995
  4055. @@ -347,7 +347,8 @@
  4056.        (strequal(dname,".") || strequal(dname,"..")))
  4057.      continue;
  4058.  
  4059. -      if (!name_convert(name2,dname,False,snum)) continue;
  4060. +      strcpy(name2,dname);
  4061. +      if (!name_map_mangle(name2,False,snum)) continue;
  4062.  
  4063.        if ((mangled && mangled_equal(name,name2))
  4064.        || fname_equal(name, name2))
  4065. @@ -1709,8 +1710,7 @@
  4066.  ****************************************************************************/
  4067.  BOOL unbecome_user(void )
  4068.  {
  4069. -  if (ChDir(OriginalDir) != 0)
  4070. -    DEBUG(0,("%s chdir(%s) failed\n",timestring(),OriginalDir));  
  4071. +  ChDir(OriginalDir);
  4072.  
  4073.    if (done_become_user == -1)
  4074.      return(False);
  4075. @@ -1747,7 +1747,8 @@
  4076.  #endif
  4077.    
  4078.    if (ChDir(OriginalDir) != 0)
  4079. -    DEBUG(0,("%s chdir(%s) failed\n",timestring(),OriginalDir));  
  4080. +    DEBUG(0,("%s chdir(%s) failed in unbecome_user\n",
  4081. +         timestring(),OriginalDir));  
  4082.  
  4083.    DEBUG(5,("unbecome_user now uid=(%d,%d) gid=(%d,%d)\n",
  4084.      getuid(),geteuid(),getgid(),getegid()));
  4085. @@ -3143,7 +3144,7 @@
  4086.    standard_sub(cnum,fname);
  4087.    trim_string(fname,"","/");
  4088.  
  4089. -  if (!directory_exist(fname))
  4090. +  if (!directory_exist(fname,NULL))
  4091.      mkdir(fname,0755);
  4092.  
  4093.    strcat(fname,"/");
  4094. @@ -3208,10 +3209,8 @@
  4095.    crec.uid = Connections[cnum].uid;
  4096.    crec.gid = Connections[cnum].gid;
  4097.    StrnCpy(crec.name,lp_servicename(snum),sizeof(crec.name)-1);
  4098. -  {
  4099. -    time_t t = time(NULL);
  4100. -    crec.start = t + GMT_TO_LOCAL*TimeDiff(t);
  4101. -  }
  4102. +  crec.start = time(NULL);
  4103. +
  4104.    {
  4105.      extern struct from_host Client_info;
  4106.      StrnCpy(crec.machine,Client_info.name,sizeof(crec.machine)-1);
  4107. @@ -3744,7 +3743,7 @@
  4108.      uint32 a = interpret_addr("localhost");
  4109.      putip((void *)&ip,(void *)&a);
  4110.      *OutBuffer = 0;
  4111. -    send_packet(OutBuffer,1,&ip,137,SOCK_DGRAM);
  4112. +    send_one_packet(OutBuffer,1,&ip,137,SOCK_DGRAM);
  4113.    }
  4114.  #endif    
  4115.    
  4116. @@ -3963,6 +3962,8 @@
  4117.  #ifdef OSF1_ENH_SEC
  4118.    set_auth_parameters(argc,argv);
  4119.  #endif
  4120. +
  4121. +  TimeInit();
  4122.  
  4123.    charset_initialise();
  4124.  
  4125. diff -u -r --new-file last-version/source/smb.h samba-1.9.14p3/source/smb.h
  4126. --- last-version/source/smb.h    Sat Nov  4 22:13:27 1995
  4127. +++ samba-1.9.14p3/source/smb.h    Tue Nov  7 18:24:53 1995
  4128. @@ -210,6 +210,7 @@
  4129.    int mode;
  4130.    int uid;
  4131.    int gid;
  4132. +  /* these times are normally kept in GMT */
  4133.    time_t mtime;
  4134.    time_t atime;
  4135.    time_t ctime;
  4136. @@ -695,7 +696,7 @@
  4137.  void add_session_user(char *user);
  4138.  int valid_uid(int uid);
  4139.  user_struct *get_valid_user_struct(int uid);
  4140. -BOOL password_ok(char *user,char *password, int pwlen, struct passwd *pwd);
  4141. +BOOL password_ok(char *user,char *password, int pwlen, struct passwd *pwd, BOOL nt_password);
  4142.  void register_uid(int uid,int gid,char *name,BOOL guest);
  4143.  BOOL fromhost(int sock,struct from_host *f);
  4144.  BOOL strhasupper(char *s);
  4145. @@ -707,7 +708,7 @@
  4146.  BOOL check_file_sharing(int cnum,char *fname);
  4147.  char *StrCpy(char *dest,char *src);
  4148.  int unix_error_packet(char *inbuf,char *outbuf,int def_class,uint32 def_code,int line);
  4149. -time_t make_unix_date2(void *date_ptr,BOOL add_dst);
  4150. +time_t make_unix_date2(void *date_ptr);
  4151.  int cached_error_packet(char *inbuf,char *outbuf,int fnum,int line);
  4152.  mode_t unix_mode(int cnum,int dosmode);
  4153.  BOOL check_name(char *name,int cnum);
  4154. @@ -724,7 +725,7 @@
  4155.  BOOL yield_connection(int cnum,char *name,int max_connections);
  4156.  int count_chars(char *s,char c);
  4157.  int smbrun(char *,char *);
  4158. -BOOL name_convert(char *OutName,char *InName,BOOL need83,int snum);
  4159. +BOOL name_map_mangle(char *OutName,BOOL need83,int snum);
  4160.  struct hostent *Get_Hostbyname(char *name);
  4161.  struct passwd *Get_Pwnam(char *user,BOOL allow_change);
  4162.  void Abort(void);
  4163. @@ -738,7 +739,9 @@
  4164.  void string_free(char **s);
  4165.  char *attrib_string(int mode);
  4166.  void unix_format(char *fname);
  4167. -BOOL directory_exist(char *dname);
  4168. +BOOL directory_exist(char *dname,struct stat *st);
  4169. +time_t make_unix_date3(void *date_ptr);
  4170. +void put_dos_date3(char *buf,int offset,time_t unixdate);
  4171.  void make_dir_struct(char *buf,char *mask,char *fname,unsigned int size,int mode,time_t date);
  4172.  BOOL in_list(char *s,char *list,BOOL case_sensitive);
  4173.  void strupper(char *s);
  4174. @@ -767,7 +770,7 @@
  4175.  int dos_mode(int ,char *,struct stat *);
  4176.  char *timestring();
  4177.  BOOL ip_equal(struct in_addr *ip1,struct in_addr *ip2);
  4178. -BOOL send_packet(char *buf,int len,struct in_addr *ip,int port,int type);
  4179. +BOOL send_one_packet(char *buf,int len,struct in_addr *ip,int port,int type);
  4180.  char *get_home_dir(char *);
  4181.  int set_filelen(int fd, long len);
  4182.  void put_dos_date(char *buf,int offset,time_t unixdate);
  4183. @@ -776,7 +779,7 @@
  4184.  int name_len(char *s);
  4185.  void dos_clean_name(char *s);
  4186.  void unix_clean_name(char *s);
  4187. -time_t make_unix_date(void *date_ptr,BOOL add_dst);
  4188. +time_t make_unix_date(void *date_ptr);
  4189.  BOOL lanman2_match( char *str, char *regexp, int case_sig, BOOL autoext);
  4190.  BOOL trim_string(char *s,char *front,char *back);
  4191.  int byte_checksum(char *buf,int len);
  4192. diff -u -r --new-file last-version/source/smbencrypt.c samba-1.9.14p3/source/smbencrypt.c
  4193. --- last-version/source/smbencrypt.c    Tue Jul 11 21:56:15 1995
  4194. +++ samba-1.9.14p3/source/smbencrypt.c    Sun Nov  5 15:46:54 1995
  4195. @@ -24,12 +24,24 @@
  4196.  #include "includes.h"
  4197.  #include "loadparm.h"
  4198.  #include "des.h"
  4199. +#include "md4.h"
  4200.  
  4201.  extern int DEBUGLEVEL;
  4202.  
  4203.  #ifndef uchar
  4204.  #define uchar unsigned char
  4205.  #endif
  4206. +#ifndef int16
  4207. +#define int16 unsigned short
  4208. +#endif
  4209. +#ifndef uint16
  4210. +#define uint16 unsigned short
  4211. +#endif
  4212. +#ifndef uint32
  4213. +#define uint32 unsigned int
  4214. +#endif
  4215. +
  4216. +#include "byteorder.h"
  4217.  
  4218.  void str_to_key(uchar *str,uchar *key)
  4219.  {
  4220. @@ -110,6 +122,81 @@
  4221.    E_P16(p14, p21);
  4222.    E_P24(p21, c8, p24);
  4223.  }
  4224. +
  4225. +/* Routines for Windows NT MD4 Hash functions. */
  4226. +static int _my_wcslen(int16 *str)
  4227. +{
  4228. +    int len = 0;
  4229. +    while(*str++ != 0)
  4230. +        len++;
  4231. +    return len;
  4232. +}
  4233. +
  4234. +/*
  4235. + * Convert a string into an NT UNICODE string.
  4236. + * Note that regardless of processor type 
  4237. + * this must be in intel (little-endian)
  4238. + * format.
  4239. + */
  4240. + 
  4241. +static int _my_mbstowcs(int16 *dst, uchar *src, int len)
  4242. +{
  4243. +    int i;
  4244. +    int16 val;
  4245. + 
  4246. +    for(i = 0; i < len; i++) {
  4247. +        val = *src;
  4248. +        SSVAL(dst,0,val);
  4249. +        dst++;
  4250. +        src++;
  4251. +        if(val == 0)
  4252. +            break;
  4253. +    }
  4254. +    return i;
  4255. +}
  4256. +
  4257. +/* 
  4258. + * Creates the MD4 Hash of the users password in NT UNICODE.
  4259. + */
  4260. + 
  4261. +void E_md4hash(uchar *passwd, uchar *p16)
  4262. +{
  4263. +    int i, len;
  4264. +    int16 wpwd[129];
  4265. +    MDstruct MD;
  4266. + 
  4267. +    /* Password cannot be longer than 128 characters */
  4268. +    len = strlen(passwd);
  4269. +    if(len > 128)
  4270. +        len = 128;
  4271. +    /* Password must be converted to NT unicode */
  4272. +    _my_mbstowcs( wpwd, passwd, len);
  4273. +    wpwd[len] = 0; /* Ensure string is null terminated */
  4274. +    /* Calculate length in bytes */
  4275. +    len = _my_wcslen(wpwd) * sizeof(int16);
  4276. + 
  4277. +    MDbegin(&MD);
  4278. +    for(i = 0; i + 64 <= len; i += 64)
  4279. +        MDupdate(&MD,wpwd + (i/2), 512);
  4280. +    MDupdate(&MD,wpwd + (i/2),(len-i)*8);
  4281. +    SIVAL(p16,0,MD.buffer[0]);
  4282. +    SIVAL(p16,4,MD.buffer[1]);
  4283. +    SIVAL(p16,8,MD.buffer[2]);
  4284. +    SIVAL(p16,12,MD.buffer[3]);
  4285. +}
  4286. +
  4287. +/* Does the NT MD4 hash then des encryption. */
  4288. + 
  4289. +void SMBNTencrypt(uchar *passwd, uchar *c8, uchar *p24)
  4290. +{
  4291. +    uchar p21[21];
  4292. + 
  4293. +    memset(p21,'\0',21);
  4294. + 
  4295. +    E_md4hash(passwd, p21);    
  4296. +    E_P24(p21, c8, p24);
  4297. +}
  4298. +
  4299.  #else
  4300.  void smbencrypt_dummy(void){}
  4301.  #endif
  4302. diff -u -r --new-file last-version/source/smbpass.c samba-1.9.14p3/source/smbpass.c
  4303. --- last-version/source/smbpass.c    Sun Sep 10 23:10:41 1995
  4304. +++ samba-1.9.14p3/source/smbpass.c    Mon Nov  6 16:54:57 1995
  4305. @@ -1,281 +1,304 @@
  4306.  #ifdef SMB_PASSWD
  4307. -/* 
  4308. -   Unix SMB/Netbios implementation.
  4309. -   Version 1.9.
  4310. -   SMB parameters and setup
  4311. -   Copyright (C) Andrew Tridgell 1992-1995
  4312. -   Modified by Jeremy Allison 1995.
  4313. -   
  4314. -   This program is free software; you can redistribute it and/or modify
  4315. -   it under the terms of the GNU General Public License as published by
  4316. -   the Free Software Foundation; either version 2 of the License, or
  4317. -   (at your option) any later version.
  4318. -   
  4319. -   This program is distributed in the hope that it will be useful,
  4320. -   but WITHOUT ANY WARRANTY; without even the implied warranty of
  4321. -   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  4322. -   GNU General Public License for more details.
  4323. -   
  4324. -   You should have received a copy of the GNU General Public License
  4325. -   along with this program; if not, write to the Free Software
  4326. -   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  4327. -*/
  4328. +/*
  4329. + * Unix SMB/Netbios implementation. Version 1.9. SMB parameters and setup
  4330. + * Copyright (C) Andrew Tridgell 1992-1995 Modified by Jeremy Allison 1995.
  4331. + * 
  4332. + * This program is free software; you can redistribute it and/or modify it under
  4333. + * the terms of the GNU General Public License as published by the Free
  4334. + * Software Foundation; either version 2 of the License, or (at your option)
  4335. + * any later version.
  4336. + * 
  4337. + * This program is distributed in the hope that it will be useful, but WITHOUT
  4338. + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  4339. + * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
  4340. + * more details.
  4341. + * 
  4342. + * You should have received a copy of the GNU General Public License along with
  4343. + * this program; if not, write to the Free Software Foundation, Inc., 675
  4344. + * Mass Ave, Cambridge, MA 02139, USA.
  4345. + */
  4346.  
  4347.  #include "includes.h"
  4348.  #include "loadparm.h"
  4349.  
  4350. -extern int DEBUGLEVEL;
  4351. +extern int      DEBUGLEVEL;
  4352.  
  4353. -int gotalarm;
  4354. +int             gotalarm;
  4355.  
  4356. -void gotalarm_sig()
  4357. +void 
  4358. +gotalarm_sig()
  4359.  {
  4360. -    gotalarm = 1;
  4361. +    gotalarm = 1;
  4362.  }
  4363.  
  4364. -int do_pw_lock(int fd, int waitsecs, int type)
  4365. +int 
  4366. +do_pw_lock(int fd, int waitsecs, int type)
  4367.  {
  4368. -    struct flock lock;
  4369. -    int ret;
  4370. +    struct flock    lock;
  4371. +    int             ret;
  4372.  
  4373. -    gotalarm = 0;
  4374. +    gotalarm = 0;
  4375.      signal(SIGALRM, SIGNAL_CAST gotalarm_sig);
  4376.  
  4377. -    lock.l_type = type;
  4378. -    lock.l_whence = SEEK_SET;
  4379. -    lock.l_start = 0;
  4380. -    lock.l_len = 1;
  4381. -    lock.l_pid = 0;
  4382. -
  4383. -    alarm(5);
  4384. -    ret = fcntl(fd, F_SETLKW, &lock);
  4385. -    alarm(0);
  4386. -    signal( SIGALRM, SIGNAL_CAST SIG_DFL);
  4387. -
  4388. -    if(gotalarm) {
  4389. -        DEBUG(0,("do_pw_lock: failed to %s SMB passwd file.\n",
  4390. -        type == F_UNLCK ? "unlock" : "lock" ));
  4391. -        return -1;
  4392. -    }
  4393. -    return ret;
  4394. +    lock.l_type = type;
  4395. +    lock.l_whence = SEEK_SET;
  4396. +    lock.l_start = 0;
  4397. +    lock.l_len = 1;
  4398. +    lock.l_pid = 0;
  4399. +
  4400. +    alarm(5);
  4401. +    ret = fcntl(fd, F_SETLKW, &lock);
  4402. +    alarm(0);
  4403. +    signal(SIGALRM, SIGNAL_CAST SIG_DFL);
  4404. +
  4405. +    if (gotalarm) {
  4406. +        DEBUG(0, ("do_pw_lock: failed to %s SMB passwd file.\n",
  4407. +              type == F_UNLCK ? "unlock" : "lock"));
  4408. +        return -1;
  4409. +    }
  4410. +    return ret;
  4411.  }
  4412.  
  4413. -int pw_file_lock(const char *name, int type, int secs)
  4414. +int 
  4415. +pw_file_lock(char *name, int type, int secs)
  4416.  {
  4417. -    int fd = open(name,O_RDWR|O_CREAT,0666);
  4418. -    if (fd < 0) return(-1);
  4419. -    if(do_pw_lock(fd, secs, type))
  4420. -      {
  4421. +    int             fd = open(name, O_RDWR | O_CREAT, 0666);
  4422. +    if (fd < 0)
  4423. +        return (-1);
  4424. +    if (do_pw_lock(fd, secs, type)) {
  4425.          close(fd);
  4426.          return -1;
  4427. -      }
  4428. +    }
  4429.      return fd;
  4430.  }
  4431.  
  4432. -int pw_file_unlock(int fd)
  4433. +int 
  4434. +pw_file_unlock(int fd)
  4435.  {
  4436.      do_pw_lock(fd, 5, F_UNLCK);
  4437.      return close(fd);
  4438.  }
  4439.  
  4440.  /*
  4441. - * Routine to search the smbpasswd file for an
  4442. - * entry matching the username.
  4443. + * Routine to get the next 32 hex characters and turn them
  4444. + * into a 16 byte array.
  4445.   */
  4446. -struct smb_passwd *get_smbpwnam(char *name)
  4447. +
  4448. +static int gethexpwd(char *p, char *pwd)
  4449.  {
  4450. -  /* Static buffers we will return. */
  4451. -  static struct smb_passwd pw_buf;
  4452. -  static pstring user_name;
  4453. -  static unsigned char smbpwd[16];
  4454. -  char linebuf[256];
  4455. -  char readbuf[16*1024];
  4456. -  unsigned char c;
  4457. -  unsigned char *p;
  4458. -  long uidval;
  4459. -  long linebuf_len;
  4460. -  unsigned char lonybble, hinybble;
  4461. -  int i;
  4462. -  FILE *fp;
  4463. -  int lockfd;
  4464. -  char *pfile = lp_smb_passwd_file();
  4465. -
  4466. -  if (!*pfile) {
  4467. -    DEBUG(0,("No SMB password file set\n"));
  4468. -    return(NULL);
  4469. -  }
  4470. -
  4471. -  DEBUG(10,("get_smbpwnam: opening file %s\n", pfile));
  4472. -  
  4473. -  fp = fopen(pfile,"r");
  4474. -  
  4475. -  if(fp == NULL) 
  4476. -    {
  4477. -      DEBUG(0,("get_smbpwnam: unable to open file %s\n", pfile));
  4478. -      return NULL;
  4479. -    }
  4480. -
  4481. -  /* Set a 16k buffer to do more efficient reads */  
  4482. -  setvbuf(fp, readbuf, _IOFBF, sizeof(readbuf));
  4483. -
  4484. -  if((lockfd = pw_file_lock(pfile,F_RDLCK,5))<0) {
  4485. -    DEBUG(0,("get_smbpwnam: unable to lock file %s\n", pfile));
  4486. -    fclose(fp);
  4487. -    return NULL;
  4488. -  }
  4489. -
  4490. -  /* make sure it is only rw by the owner */
  4491. -  chmod(pfile,0600);
  4492. -  
  4493. -  /* We have a read lock on the file. */
  4494. -  /* Scan the file, a line at a time and
  4495. -     check if the name matches. */
  4496. -  while(!feof(fp)) 
  4497. -    {
  4498. -      linebuf[0] = '\0';
  4499. -
  4500. -      fgets(linebuf, 256, fp);
  4501. -      if(ferror(fp))
  4502. -    {
  4503. -      fclose(fp);
  4504. -      pw_file_unlock(lockfd);
  4505. -      return NULL;
  4506. +    int i;
  4507. +    unsigned char   lonybble, hinybble;
  4508. +    char           *hexchars = "0123456789ABCDEF";
  4509. +    char           *p1, *p2;
  4510. +
  4511. +    for (i = 0; i < 32; i += 2) {
  4512. +        hinybble = toupper(p[i]);
  4513. +        lonybble = toupper(p[i + 1]);
  4514. + 
  4515. +        p1 = strchr(hexchars, hinybble);
  4516. +        p2 = strchr(hexchars, lonybble);
  4517. +        if (!p1 || !p2)
  4518. +            return (False);
  4519. +        hinybble = PTR_DIFF(p1, hexchars);
  4520. +        lonybble = PTR_DIFF(p2, hexchars);
  4521. + 
  4522. +        pwd[i / 2] = (hinybble << 4) | lonybble;
  4523.      }
  4524. +    return (True);
  4525. +}
  4526.  
  4527. -      /* Check if the string is terminated with a newline -
  4528. -     if not then we must keep reading and discard until
  4529. -     we get one.
  4530. -     */
  4531. -      linebuf_len = strlen(linebuf);
  4532. -      if(linebuf[linebuf_len-1] != '\n')
  4533. -    {
  4534. -      c = '\0';
  4535. -      while(!ferror(fp) && !feof(fp))
  4536. -        {
  4537. -          c = fgetc(fp);
  4538. -          if(c == '\n')
  4539. -        break;
  4540. -        }
  4541. +/*
  4542. + * Routine to search the smbpasswd file for an entry matching the username.
  4543. + */
  4544. +struct smb_passwd *
  4545. +get_smbpwnam(char *name)
  4546. +{
  4547. +    /* Static buffers we will return. */
  4548. +    static struct smb_passwd pw_buf;
  4549. +    static pstring  user_name;
  4550. +    static unsigned char smbpwd[16];
  4551. +    static unsigned char smbntpwd[16];
  4552. +    char            linebuf[256];
  4553. +    char            readbuf[16 * 1024];
  4554. +    unsigned char   c;
  4555. +    unsigned char  *p;
  4556. +    long            uidval;
  4557. +    long            linebuf_len;
  4558. +    FILE           *fp;
  4559. +    int             lockfd;
  4560. +    char           *pfile = lp_smb_passwd_file();
  4561. +
  4562. +    if (!*pfile) {
  4563. +        DEBUG(0, ("No SMB password file set\n"));
  4564. +        return (NULL);
  4565.      }
  4566. -      else
  4567. -    linebuf[linebuf_len-1] = '\0';
  4568. +    DEBUG(10, ("get_smbpwnam: opening file %s\n", pfile));
  4569.  
  4570. -#ifdef DEBUG_PASSWORD
  4571. -      DEBUG(100, ("get_smbpwnam: got line |%s|\n", linebuf));
  4572. -#endif
  4573. -      if((linebuf[0] == 0) && feof(fp))
  4574. -    {
  4575. -      DEBUG(4,("get_smbpwnam: end of file reached\n"));
  4576. -      break;
  4577. -    }
  4578. -      /* The line we have should be of the form :-
  4579. -     
  4580. -     username:uid:[32hex bytes]:....other flags presently ignored....
  4581. -     
  4582. -     */
  4583. +    fp = fopen(pfile, "r");
  4584.  
  4585. -      if(linebuf[0] == '#' || linebuf[0] == '\0')
  4586. -    {
  4587. -      DEBUG(6,("get_smbpwnam: skipping comment or blank line\n"));
  4588. -      continue;
  4589. -    }
  4590. -      p = (unsigned char *)strchr(linebuf, ':');
  4591. -      if( p == NULL)
  4592. -    {
  4593. -      DEBUG(0,("get_smbpwnam: malformed password entry (no :)\n"));
  4594. -      continue;
  4595. +    if (fp == NULL) {
  4596. +        DEBUG(0, ("get_smbpwnam: unable to open file %s\n", pfile));
  4597. +        return NULL;
  4598.      }
  4599. -      /* As 256 is shorter than a pstring we don't
  4600. -     need to check length here - if this ever changes.... */
  4601. -      strncpy(user_name, linebuf, PTR_DIFF(p,linebuf));
  4602. -      user_name[PTR_DIFF(p,linebuf)] = '\0';
  4603. -      if(!strequal(user_name, name))
  4604. -    continue;
  4605. -
  4606. -      /* User name matches - get uid and password */
  4607. -      p++;            /* Go past ':' */
  4608. -      if(!isdigit(*p)) {
  4609. -    DEBUG(0,("get_smbpwnam: malformed password entry (uid not number)\n"));
  4610. -    fclose(fp);
  4611. -    pw_file_unlock(lockfd);
  4612. -    return NULL;
  4613. -      }
  4614. +    /* Set a 16k buffer to do more efficient reads */
  4615. +    setvbuf(fp, readbuf, _IOFBF, sizeof(readbuf));
  4616.  
  4617. -      uidval = atoi((char *)p);
  4618. -      while (*p && isdigit(*p)) p++;
  4619. -      if(*p != ':') {
  4620. -    DEBUG(0,("get_smbpwnam: malformed password entry (no : after uid)\n"));
  4621. -    fclose(fp);
  4622. -    pw_file_unlock(lockfd);
  4623. -    return NULL;
  4624. -      }
  4625. +    if ((lockfd = pw_file_lock(pfile, F_RDLCK, 5)) < 0) {
  4626. +        DEBUG(0, ("get_smbpwnam: unable to lock file %s\n", pfile));
  4627. +        fclose(fp);
  4628. +        return NULL;
  4629. +    }
  4630. +    /* make sure it is only rw by the owner */
  4631. +    chmod(pfile, 0600);
  4632.  
  4633. -      /* Now get the password value - this should be 32 hex digits which
  4634. -     are the ascii representations of a 16 byte string. Get two at
  4635. -     a time and put them into the password.
  4636. +    /* We have a read lock on the file. */
  4637. +    /*
  4638. +     * Scan the file, a line at a time and check if the name matches.
  4639.       */
  4640. -      p++;
  4641. -      if(*p == '*' || *p == 'X') {
  4642. -    /* Password deliberately invalid - end here. */
  4643. -    DEBUG(10,("get_smbpwnam: entry invalidated for user %s\n",user_name));
  4644. -    fclose(fp);
  4645. -    pw_file_unlock(lockfd);
  4646. -    return NULL;
  4647. -      }
  4648. -      if(linebuf_len < (PTR_DIFF(p,linebuf) + 33)) {
  4649. -    DEBUG(0,("get_smbpwnam: malformed password entry (passwd too short)\n"));
  4650. -    fclose(fp);
  4651. -    pw_file_unlock(lockfd);
  4652. -    return(False);
  4653. -      }
  4654. +    while (!feof(fp)) {
  4655. +        linebuf[0] = '\0';
  4656. +
  4657. +        fgets(linebuf, 256, fp);
  4658. +        if (ferror(fp)) {
  4659. +            fclose(fp);
  4660. +            pw_file_unlock(lockfd);
  4661. +            return NULL;
  4662. +        }
  4663. +        /*
  4664. +         * Check if the string is terminated with a newline - if not
  4665. +         * then we must keep reading and discard until we get one.
  4666. +         */
  4667. +        linebuf_len = strlen(linebuf);
  4668. +        if (linebuf[linebuf_len - 1] != '\n') {
  4669. +            c = '\0';
  4670. +            while (!ferror(fp) && !feof(fp)) {
  4671. +                c = fgetc(fp);
  4672. +                if (c == '\n')
  4673. +                    break;
  4674. +            }
  4675. +        } else
  4676. +            linebuf[linebuf_len - 1] = '\0';
  4677. +
  4678. +#ifdef DEBUG_PASSWORD
  4679. +        DEBUG(100, ("get_smbpwnam: got line |%s|\n", linebuf));
  4680. +#endif
  4681. +        if ((linebuf[0] == 0) && feof(fp)) {
  4682. +            DEBUG(4, ("get_smbpwnam: end of file reached\n"));
  4683. +            break;
  4684. +        }
  4685. +        /*
  4686. +         * The line we have should be of the form :-
  4687. +         * 
  4688. +         * username:uid:[32hex bytes]:....other flags presently
  4689. +         * ignored....
  4690. +         * 
  4691. +         * or,
  4692. +         *
  4693. +         * username:uid:[32hex bytes]:[32hex bytes]:....ignored....
  4694. +         *
  4695. +         * if Windows NT compatible passwords are also present.
  4696. +         */
  4697. +
  4698. +        if (linebuf[0] == '#' || linebuf[0] == '\0') {
  4699. +            DEBUG(6, ("get_smbpwnam: skipping comment or blank line\n"));
  4700. +            continue;
  4701. +        }
  4702. +        p = (unsigned char *) strchr(linebuf, ':');
  4703. +        if (p == NULL) {
  4704. +            DEBUG(0, ("get_smbpwnam: malformed password entry (no :)\n"));
  4705. +            continue;
  4706. +        }
  4707. +        /*
  4708. +         * As 256 is shorter than a pstring we don't need to check
  4709. +         * length here - if this ever changes....
  4710. +         */
  4711. +        strncpy(user_name, linebuf, PTR_DIFF(p, linebuf));
  4712. +        user_name[PTR_DIFF(p, linebuf)] = '\0';
  4713. +        if (!strequal(user_name, name))
  4714. +            continue;
  4715. +
  4716. +        /* User name matches - get uid and password */
  4717. +        p++;        /* Go past ':' */
  4718. +        if (!isdigit(*p)) {
  4719. +            DEBUG(0, ("get_smbpwnam: malformed password entry (uid not number)\n"));
  4720. +            fclose(fp);
  4721. +            pw_file_unlock(lockfd);
  4722. +            return NULL;
  4723. +        }
  4724. +        uidval = atoi((char *) p);
  4725. +        while (*p && isdigit(*p))
  4726. +            p++;
  4727. +        if (*p != ':') {
  4728. +            DEBUG(0, ("get_smbpwnam: malformed password entry (no : after uid)\n"));
  4729. +            fclose(fp);
  4730. +            pw_file_unlock(lockfd);
  4731. +            return NULL;
  4732. +        }
  4733. +        /*
  4734. +         * Now get the password value - this should be 32 hex digits
  4735. +         * which are the ascii representations of a 16 byte string.
  4736. +         * Get two at a time and put them into the password.
  4737. +         */
  4738. +        p++;
  4739. +        if (*p == '*' || *p == 'X') {
  4740. +            /* Password deliberately invalid - end here. */
  4741. +            DEBUG(10, ("get_smbpwnam: entry invalidated for user %s\n", user_name));
  4742. +            fclose(fp);
  4743. +            pw_file_unlock(lockfd);
  4744. +            return NULL;
  4745. +        }
  4746. +        if (linebuf_len < (PTR_DIFF(p, linebuf) + 33)) {
  4747. +            DEBUG(0, ("get_smbpwnam: malformed password entry (passwd too short)\n"));
  4748. +            fclose(fp);
  4749. +            pw_file_unlock(lockfd);
  4750. +            return (False);
  4751. +        }
  4752. +        if (p[32] != ':') {
  4753. +            DEBUG(0, ("get_smbpwnam: malformed password entry (no terminating :)\n"));
  4754. +            fclose(fp);
  4755. +            pw_file_unlock(lockfd);
  4756. +            return NULL;
  4757. +        }
  4758. +        if (!strncasecmp((char *) p, "NO PASSWORD", 11)) {
  4759. +            pw_buf.smb_passwd = NULL;
  4760. +        } else {
  4761. +            if(!gethexpwd(p,smbpwd)) {
  4762. +                DEBUG(0, ("Malformed Lanman password entry (non hex chars)\n"));
  4763. +                fclose(fp);
  4764. +                pw_file_unlock(lockfd);
  4765. +                return NULL;
  4766. +            }
  4767. +            pw_buf.smb_passwd = smbpwd;
  4768. +        }
  4769. +        pw_buf.smb_name = user_name;
  4770. +        pw_buf.smb_userid = uidval;
  4771. +        pw_buf.smb_nt_passwd = NULL;
  4772. +
  4773. +        /* Now check if the NT compatible password is
  4774. +            available. */
  4775. +        p += 33; /* Move to the first character of the line after
  4776. +                    the lanman password. */
  4777. +        if ((linebuf_len >= (PTR_DIFF(p, linebuf) + 33)) && (p[32] == ':')) {
  4778. +            if (*p != '*' && *p != 'X') {
  4779. +                if(gethexpwd(p,smbntpwd))
  4780. +                    pw_buf.smb_nt_passwd = smbntpwd;
  4781. +            }
  4782. +        }
  4783. +
  4784. +        fclose(fp);
  4785. +        pw_file_unlock(lockfd);
  4786. +        DEBUG(5, ("get_smbpwname: returning passwd entry for user %s, uid %d\n",
  4787. +              user_name, uidval));
  4788. +        return &pw_buf;
  4789. +    }
  4790.  
  4791. -      if(p[32] != ':') {
  4792. -    DEBUG(0,("get_smbpwnam: malformed password entry (no terminating :)\n"));
  4793.      fclose(fp);
  4794.      pw_file_unlock(lockfd);
  4795.      return NULL;
  4796. -      }
  4797. -
  4798. -      if (!strncasecmp((char *)p,"NO PASSWORD", 11)) {
  4799. -    pw_buf.smb_passwd = NULL;
  4800. -      } else {    
  4801. -    char *hexchars = "0123456789ABCDEF";
  4802. -    char *p1,*p2;
  4803. -    for(i = 0; i < 32; i += 2)
  4804. -      {
  4805. -        hinybble = toupper(p[i]);
  4806. -        lonybble = toupper(p[i+1]);
  4807. -        
  4808. -        p1 = strchr(hexchars,hinybble);
  4809. -        p2 = strchr(hexchars,lonybble);
  4810. -        if (!p1 || !p2) {
  4811. -          DEBUG(0,("Malformed password entry (non hex chars)\n"));
  4812. -          fclose(fp);
  4813. -          pw_file_unlock(lockfd);
  4814. -          return NULL;
  4815. -        }
  4816. -
  4817. -        hinybble = PTR_DIFF(p1,hexchars);
  4818. -        lonybble = PTR_DIFF(p2,hexchars);
  4819. -
  4820. -        smbpwd[i/2] = (hinybble << 4) | lonybble;
  4821. -      }
  4822. -    pw_buf.smb_passwd = smbpwd;
  4823. -      }
  4824. -      pw_buf.smb_name = user_name;
  4825. -      pw_buf.smb_userid = uidval;
  4826. -      fclose(fp);
  4827. -      pw_file_unlock(lockfd);
  4828. -      DEBUG(5,("get_smbpwname: returning passwd entry for user %s, uid %d\n",
  4829. -        user_name, uidval));
  4830. -      return &pw_buf;
  4831. -    }
  4832. -  
  4833. -  fclose(fp);
  4834. -  pw_file_unlock(lockfd);
  4835. -  return NULL;
  4836.  }
  4837.  #else
  4838. -void smbpass_dummy(void){} /* To avoid compiler complaints */
  4839. +void 
  4840. +smbpass_dummy(void)
  4841. +{
  4842. +}                /* To avoid compiler complaints */
  4843.  #endif
  4844. -
  4845. diff -u -r --new-file last-version/source/smbpass.h samba-1.9.14p3/source/smbpass.h
  4846. --- last-version/source/smbpass.h    Sun Sep 10 23:10:47 1995
  4847. +++ samba-1.9.14p3/source/smbpass.h    Mon Nov  6 16:54:56 1995
  4848. @@ -25,6 +25,7 @@
  4849.      int smb_userid;
  4850.      char *smb_name;
  4851.      unsigned char *smb_passwd; /* Null if no password */
  4852. +    unsigned char *smb_nt_passwd; /* Null if no password */
  4853.      /* Other fields / flags may be added later */
  4854.  };
  4855.  
  4856. @@ -39,9 +40,11 @@
  4857.  void str_to_key(unsigned char *str,unsigned char *key);
  4858.  void E_P16(uchar *p14,uchar *p16);
  4859.  void E_P24(unsigned char *p21, unsigned char *c8, unsigned char *p24);
  4860. +void E_md4hash(uchar *passwd,uchar *p16);
  4861.  void SMBencrypt(unsigned char *passwd, unsigned char *c8, unsigned char *p24);
  4862. +void SMB_nt_encrypt(unsigned char *passwd, unsigned char *c8, unsigned char *p24);
  4863.  
  4864.  /* Password file lock/unlock routines */
  4865. -int pw_file_lock(const char *name, int type, int secs);
  4866. +int pw_file_lock(char *name, int type, int secs);
  4867.  int pw_file_unlock(int fd);
  4868.  #endif
  4869. diff -u -r --new-file last-version/source/smbpasswd.c samba-1.9.14p3/source/smbpasswd.c
  4870. --- last-version/source/smbpasswd.c    Sun Sep 10 23:28:28 1995
  4871. +++ samba-1.9.14p3/source/smbpasswd.c    Mon Nov  6 16:54:38 1995
  4872. @@ -1,381 +1,447 @@
  4873.  #ifdef SMB_PASSWD
  4874.  
  4875. -/* 
  4876. -   Unix SMB/Netbios implementation.
  4877. -   Version 1.9.
  4878. -   smbpasswd module.
  4879. -   Copyright (C) Jeremy Allison 1995.
  4880. -
  4881. -   This program is free software; you can redistribute it and/or modify
  4882. -   it under the terms of the GNU General Public License as published by
  4883. -   the Free Software Foundation; either version 2 of the License, or
  4884. -   (at your option) any later version.
  4885. -   
  4886. -   This program is distributed in the hope that it will be useful,
  4887. -   but WITHOUT ANY WARRANTY; without even the implied warranty of
  4888. -   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  4889. -   GNU General Public License for more details.
  4890. -   
  4891. -   You should have received a copy of the GNU General Public License
  4892. -   along with this program; if not, write to the Free Software
  4893. -   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  4894. -*/
  4895. +/*
  4896. + * Unix SMB/Netbios implementation. Version 1.9. smbpasswd module. Copyright
  4897. + * (C) Jeremy Allison 1995.
  4898. + * 
  4899. + * This program is free software; you can redistribute it and/or modify it under
  4900. + * the terms of the GNU General Public License as published by the Free
  4901. + * Software Foundation; either version 2 of the License, or (at your option)
  4902. + * any later version.
  4903. + * 
  4904. + * This program is distributed in the hope that it will be useful, but WITHOUT
  4905. + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  4906. + * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
  4907. + * more details.
  4908. + * 
  4909. + * You should have received a copy of the GNU General Public License along with
  4910. + * this program; if not, write to the Free Software Foundation, Inc., 675
  4911. + * Mass Ave, Cambridge, MA 02139, USA.
  4912. + */
  4913.  
  4914.  #include "includes.h"
  4915.  #include "des.h"
  4916.  
  4917.  #ifdef SMBGETPASS
  4918. -extern char *getsmbpass(const char *);
  4919. +extern char    *getsmbpass(char *);
  4920.  #define getpass getsmbpass
  4921.  #endif
  4922.  
  4923.  /* Static buffers we will return. */
  4924.  static struct smb_passwd pw_buf;
  4925. -static pstring user_name;
  4926. +static pstring  user_name;
  4927.  static unsigned char smbpwd[16];
  4928. +static unsigned char smbntpwd[16];
  4929.  
  4930. -struct smb_passwd *_my_get_smbpwnam(FILE *fp,char *name, BOOL *valid_old_pwd, long *pwd_seekpos)
  4931. +static int gethexpwd(char *p, char *pwd)
  4932.  {
  4933. -  char linebuf[256];
  4934. -  unsigned char c;
  4935. -  unsigned char *p;
  4936. -  long uidval;
  4937. -  long linebuf_len;
  4938. -  unsigned char lonybble, hinybble;
  4939. -  int i;
  4940. -
  4941. -  /* Scan the file, a line at a time and
  4942. -     check if the name matches. */
  4943. -  while(!feof(fp)) 
  4944. -    {
  4945. -      linebuf[0] = '\0';
  4946. -      *pwd_seekpos = ftell(fp);
  4947. +    int i;
  4948. +    unsigned char   lonybble, hinybble;
  4949. +    char           *hexchars = "0123456789ABCDEF";
  4950. +    char           *p1, *p2;
  4951. +    for (i = 0; i < 32; i += 2) {
  4952. +        hinybble = toupper(p[i]);
  4953. +        lonybble = toupper(p[i + 1]);
  4954. +
  4955. +        p1 = strchr(hexchars, hinybble);
  4956. +        p2 = strchr(hexchars, lonybble);
  4957. +        if (!p1 || !p2)
  4958. +            return (False);
  4959.  
  4960. -      fgets(linebuf, 256, fp);
  4961. -      if(ferror(fp))
  4962. -    return NULL;
  4963. +        hinybble = PTR_DIFF(p1, hexchars);
  4964. +        lonybble = PTR_DIFF(p2, hexchars);
  4965.  
  4966. -      /* Check if the string is terminated with a newline -
  4967. -     if not then we must keep reading and discard until
  4968. -     we get one.
  4969. -     */
  4970. -      linebuf_len = strlen(linebuf);
  4971. -      if(linebuf[linebuf_len-1] != '\n')
  4972. -    {
  4973. -      c = '\0';
  4974. -      while(!ferror(fp) && !feof(fp))
  4975. -        {
  4976. -          c = fgetc(fp);
  4977. -          if(c == '\n')
  4978. -        break;
  4979. -        }
  4980. -    }
  4981. -      else
  4982. -    linebuf[linebuf_len-1] = '\0';
  4983. -
  4984. -      if((linebuf[0] == 0) && feof(fp))
  4985. -    break;
  4986. -      /* The line we have should be of the form :-
  4987. +        pwd[i / 2] = (hinybble << 4) | lonybble;
  4988. +    }
  4989. +    return (True);
  4990. +}
  4991.  
  4992. -     username:uid:[32hex bytes]:....other flags presently ignored....
  4993. -     */
  4994. +struct smb_passwd *
  4995. +_my_get_smbpwnam(FILE * fp, char *name, BOOL * valid_old_pwd, 
  4996. +        BOOL *got_valid_nt_entry, long *pwd_seekpos)
  4997. +{
  4998. +    char            linebuf[256];
  4999. +    unsigned char   c;
  5000. +    unsigned char  *p;
  5001. +    long            uidval;
  5002. +    long            linebuf_len;
  5003.  
  5004. -      if(linebuf[0] == '#' || linebuf[0] == '\0')
  5005. -    continue;
  5006. -      p = (unsigned char *)strchr(linebuf, ':');
  5007. -      if( p == NULL)
  5008. -    continue;
  5009. -      /* As 256 is shorter than a pstring we don't
  5010. -     need to check length here - if this ever changes.... */
  5011. -      strncpy( user_name, linebuf, PTR_DIFF(p,linebuf));
  5012. -      user_name[PTR_DIFF(p,linebuf)] = '\0';
  5013. -      if(!strequal(user_name, name))
  5014. -    continue;
  5015. -
  5016. -      /* User name matches - get uid and password */
  5017. -      p++; /* Go past ':' */
  5018. -      if(!isdigit(*p))
  5019. -    return(False);
  5020. -      
  5021. -      uidval = atoi((char *)p);
  5022. -      while (*p && isdigit(*p)) p++;
  5023. -
  5024. -      if(*p != ':')
  5025. -    return(False);
  5026. -      
  5027. -      /* Now get the password value - this should be 32 hex digits which
  5028. -     are the ascii representations of a 16 byte string. Get two at
  5029. -     a time and put them into the password.
  5030. +    /*
  5031. +     * Scan the file, a line at a time and check if the name matches.
  5032.       */
  5033. -      p++;
  5034. -      *pwd_seekpos += PTR_DIFF(p,linebuf); /* Save exact position of
  5035. -                          passwd in file - this is used
  5036. -                          by smbpasswd.c 
  5037. -                          */
  5038. -      if(*p == '*' || *p == 'X')
  5039. -    {
  5040. -      /* Password deliberately invalid - end here. */
  5041. -      *valid_old_pwd = False;
  5042. -      pw_buf.smb_name = user_name;
  5043. -      pw_buf.smb_userid = uidval;
  5044. -      return(&pw_buf);
  5045. -    }
  5046. -      if(linebuf_len < (PTR_DIFF(p,linebuf) + 33))
  5047. -    return(False);
  5048. -      
  5049. -      if(p[32] != ':')
  5050. -    return(False);
  5051. -
  5052. -      if(!strncasecmp(p,"NO PASSWORD",11)) {
  5053. -    pw_buf.smb_passwd = NULL; /* No password */
  5054. -      } else {
  5055. -    char *hexchars = "0123456789ABCDEF";
  5056. -    char *p1,*p2;    
  5057. -    for(i = 0; i < 32; i += 2)
  5058. -      {
  5059. -        hinybble = toupper(p[i]);
  5060. -        lonybble = toupper(p[i+1]);
  5061. -        
  5062. -        p1 = strchr(hexchars,hinybble);
  5063. -        p2 = strchr(hexchars,lonybble);
  5064. -        if (!p1 || !p2)
  5065. -          return(False);
  5066. -
  5067. -        hinybble = PTR_DIFF(p1,hexchars);
  5068. -        lonybble = PTR_DIFF(p2,hexchars);
  5069. -
  5070. -        smbpwd[i/2] = (hinybble << 4) | lonybble;
  5071. -      }
  5072. -    pw_buf.smb_passwd = smbpwd;
  5073. -      }
  5074. -      
  5075. -      pw_buf.smb_name = user_name;
  5076. -      pw_buf.smb_userid = uidval;
  5077. -      *valid_old_pwd = True;
  5078. -      return &pw_buf;
  5079. -    }
  5080. -  return NULL;
  5081. +    while (!feof(fp)) {
  5082. +        linebuf[0] = '\0';
  5083. +        *pwd_seekpos = ftell(fp);
  5084. +
  5085. +        fgets(linebuf, 256, fp);
  5086. +        if (ferror(fp))
  5087. +            return NULL;
  5088. +
  5089. +        /*
  5090. +         * Check if the string is terminated with a newline - if not
  5091. +         * then we must keep reading and discard until we get one.
  5092. +         */
  5093. +        linebuf_len = strlen(linebuf);
  5094. +        if (linebuf[linebuf_len - 1] != '\n') {
  5095. +            c = '\0';
  5096. +            while (!ferror(fp) && !feof(fp)) {
  5097. +                c = fgetc(fp);
  5098. +                if (c == '\n')
  5099. +                    break;
  5100. +            }
  5101. +        } else
  5102. +            linebuf[linebuf_len - 1] = '\0';
  5103. +
  5104. +        if ((linebuf[0] == 0) && feof(fp))
  5105. +            break;
  5106. +        /*
  5107. +         * The line we have should be of the form :-
  5108. +         * 
  5109. +         * username:uid:[32hex bytes]:....other flags presently
  5110. +         * ignored....
  5111. +         * 
  5112. +         * or,
  5113. +         * 
  5114. +         * username:uid:[32hex bytes]:[32hex bytes]:....ignored....
  5115. +         * 
  5116. +         * if Windows NT compatible passwords are also present.
  5117. +         */
  5118. +
  5119. +        if (linebuf[0] == '#' || linebuf[0] == '\0')
  5120. +            continue;
  5121. +        p = (unsigned char *) strchr(linebuf, ':');
  5122. +        if (p == NULL)
  5123. +            continue;
  5124. +        /*
  5125. +         * As 256 is shorter than a pstring we don't need to check
  5126. +         * length here - if this ever changes....
  5127. +         */
  5128. +        strncpy(user_name, linebuf, PTR_DIFF(p, linebuf));
  5129. +        user_name[PTR_DIFF(p, linebuf)] = '\0';
  5130. +        if (!strequal(user_name, name))
  5131. +            continue;
  5132. +
  5133. +        /* User name matches - get uid and password */
  5134. +        p++;        /* Go past ':' */
  5135. +        if (!isdigit(*p))
  5136. +            return (False);
  5137. +
  5138. +        uidval = atoi((char *) p);
  5139. +        while (*p && isdigit(*p))
  5140. +            p++;
  5141. +
  5142. +        if (*p != ':')
  5143. +            return (False);
  5144. +
  5145. +        /*
  5146. +         * Now get the password value - this should be 32 hex digits
  5147. +         * which are the ascii representations of a 16 byte string.
  5148. +         * Get two at a time and put them into the password.
  5149. +         */
  5150. +        p++;
  5151. +        *pwd_seekpos += PTR_DIFF(p, linebuf);    /* Save exact position
  5152. +                             * of passwd in file -
  5153. +                             * this is used by
  5154. +                             * smbpasswd.c */
  5155. +        if (*p == '*' || *p == 'X') {
  5156. +            /* Password deliberately invalid - end here. */
  5157. +            *valid_old_pwd = False;
  5158. +            *got_valid_nt_entry = False;
  5159. +            pw_buf.smb_name = user_name;
  5160. +            pw_buf.smb_userid = uidval;
  5161. +            pw_buf.smb_passwd = NULL;    /* No password */
  5162. +            pw_buf.smb_nt_passwd = NULL;    /* No password */
  5163. +            return (&pw_buf);
  5164. +        }
  5165. +        if (linebuf_len < (PTR_DIFF(p, linebuf) + 33))
  5166. +            return (False);
  5167. +
  5168. +        if (p[32] != ':')
  5169. +            return (False);
  5170. +
  5171. +        if (!strncasecmp(p, "NO PASSWORD", 11)) {
  5172. +            pw_buf.smb_passwd = NULL;    /* No password */
  5173. +        } else {
  5174. +            if(!gethexpwd(p,smbpwd))
  5175. +                return False;
  5176. +            pw_buf.smb_passwd = smbpwd;
  5177. +        }
  5178. +
  5179. +        pw_buf.smb_name = user_name;
  5180. +        pw_buf.smb_userid = uidval;
  5181. +        pw_buf.smb_nt_passwd = NULL;
  5182. +        *got_valid_nt_entry = False;
  5183. +        *valid_old_pwd = True;
  5184. +
  5185. +        /* Now check if the NT compatible password is
  5186. +           available. */
  5187. +        p += 33; /* Move to the first character of the line after 
  5188. +                    the lanman password. */
  5189. +        if ((linebuf_len >= (PTR_DIFF(p, linebuf) + 33)) && (p[32] == ':')) {
  5190. +            /* NT Entry was valid - even if 'X' or '*', can be overwritten */
  5191. +            *got_valid_nt_entry = True;
  5192. +            if (*p != '*' && *p != 'X') {
  5193. +                if(gethexpwd(p,smbntpwd))
  5194. +                    pw_buf.smb_nt_passwd = smbntpwd;
  5195. +            }
  5196. +        }
  5197. +        return &pw_buf;
  5198. +    }
  5199. +    return NULL;
  5200.  }
  5201.  
  5202.  /*
  5203.   * Print command usage on stderr and die.
  5204.   */
  5205. -void usage(char *name)
  5206. +void 
  5207. +usage(char *name)
  5208.  {
  5209.      fprintf(stderr, "Usage is : %s [username]\n", name);
  5210.      exit(1);
  5211.  }
  5212.  
  5213. -int main(int argc, char **argv)
  5214. +int 
  5215. +main(int argc, char **argv)
  5216.  {
  5217. -  int real_uid;
  5218. -  struct passwd *pwd;
  5219. -  fstring old_passwd;
  5220. -  uchar old_p16[16];
  5221. -  fstring new_passwd;
  5222. -  uchar new_p16[16];
  5223. -  char *p;
  5224. -  struct smb_passwd *smb_pwent;
  5225. -  FILE *fp;
  5226. -  BOOL valid_old_pwd = False;
  5227. -  long seekpos;
  5228. -  int pwfd;
  5229. -  char ascii_p16[33];
  5230. -  char c;
  5231. -  int ret, i, err;
  5232. -  int lockfd=-1;
  5233. -  char *pfile = SMB_PASSWD_FILE;
  5234. -  char readbuf[16*1024];
  5235. +    int             real_uid;
  5236. +    struct passwd  *pwd;
  5237. +    fstring         old_passwd;
  5238. +    uchar           old_p16[16];
  5239. +    uchar           old_nt_p16[16];
  5240. +    fstring         new_passwd;
  5241. +    uchar           new_p16[16];
  5242. +    uchar           new_nt_p16[16];
  5243. +    char           *p;
  5244. +    struct smb_passwd *smb_pwent;
  5245. +    FILE           *fp;
  5246. +    BOOL            valid_old_pwd = False;
  5247. +    BOOL             got_valid_nt_entry = False;
  5248. +    long            seekpos;
  5249. +    int             pwfd;
  5250. +    char            ascii_p16[66];
  5251. +    char            c;
  5252. +    int             ret, i, err, writelen;
  5253. +    int             lockfd = -1;
  5254. +    char           *pfile = SMB_PASSWD_FILE;
  5255. +    char            readbuf[16 * 1024];
  5256.  
  5257. -  charset_initialise();
  5258. +    charset_initialise();
  5259.  
  5260.  #ifndef DEBUG_PASSWORD
  5261. -  /* Check the effective uid */
  5262. -  if(geteuid() != 0) {
  5263. -    fprintf(stderr, "%s: Must be setuid root.\n", argv[0]);
  5264. -    exit(1);
  5265. -  }
  5266. +    /* Check the effective uid */
  5267. +    if (geteuid() != 0) {
  5268. +        fprintf(stderr, "%s: Must be setuid root.\n", argv[0]);
  5269. +        exit(1);
  5270. +    }
  5271.  #endif
  5272.  
  5273. -  /* Get the real uid */
  5274. -  real_uid = getuid();
  5275. -  
  5276. -  /* Deal with usage problems */
  5277. -  if( real_uid == 0) {
  5278. -    /* As root we can change anothers password. */
  5279. -    if(argc != 1 && argc != 2)
  5280. -      usage(argv[0]);
  5281. -  } else if(argc != 1)
  5282. -    usage(argv[0]);
  5283. -        
  5284. -
  5285. -  if(real_uid == 0 && argc == 2) {
  5286. -    /* If we are root we can change anothers password. */
  5287. -    strncpy( user_name, argv[1], sizeof(user_name)-1);
  5288. -    user_name[sizeof(user_name)-1] = '\0';
  5289. -    pwd = getpwnam( user_name );
  5290. -  } else {
  5291. -    pwd = getpwuid( real_uid );
  5292. -  }
  5293. -
  5294. -  if(pwd == 0) {
  5295. -    fprintf(stderr, "%s: Unable to get UNIX password entry for user.\n", argv[0]);
  5296. -    exit(1);
  5297. -  }
  5298. -  
  5299. -  /* If we are root we don't ask for the old password. */
  5300. -  old_passwd[0] = '\0';
  5301. -  if(real_uid != 0) {
  5302. -    p = getpass("Old SMB password:");
  5303. -    strncpy(old_passwd, p, 14);
  5304. -    old_passwd[14] = '\0';
  5305. -    strupper(old_passwd);
  5306. -  }
  5307. -  
  5308. -  new_passwd[0] = '\0';
  5309. -  p = getpass("New SMB password:");
  5310. -  strncpy(new_passwd, p, 14);
  5311. -  new_passwd[14] = '\0';
  5312. -  p = getpass("Retype new SMB password:");
  5313. -  if(strncmp(p, new_passwd, 14)) {
  5314. -    fprintf(stderr, "%s: Mismatch - password unchanged.\n", argv[0]);
  5315. -    exit(1);
  5316. -  }
  5317. -  strupper(new_passwd);
  5318. -  
  5319. -  if(new_passwd[0] == '\0') {
  5320. -    printf("Password not set\n");
  5321. -    exit(0);
  5322. -  }
  5323. -  
  5324. -  /* Calculate the SMB hash functions of
  5325. -     both old an new passwords. */
  5326. -  
  5327. -  memset(old_p16,'\0',16);
  5328. -  E_P16((uchar *)old_passwd,old_p16);
  5329. -  
  5330. -  memset(new_p16,'\0',16);
  5331. -  E_P16((uchar *)new_passwd,new_p16);
  5332. -  
  5333. -  /* Open the smbpaswd file XXXX - we need to parse smb.conf to
  5334. -     get the filename */
  5335. -  if((fp = fopen(pfile, "r+")) == NULL) {
  5336. -    err = errno;
  5337. -    fprintf(stderr, "%s: Failed to open password file %s.\n", 
  5338. -        argv[0], pfile);
  5339. -    errno = err;
  5340. -    perror(argv[0]);
  5341. -    exit(err);
  5342. -  }
  5343. -
  5344. -  /* Set read buffer to 16k for effiecient reads */ 
  5345. -  setvbuf(fp, readbuf, _IOFBF, sizeof(readbuf));
  5346. - 
  5347. -  /* make sure it is only rw by the owner */
  5348. -  chmod(pfile,0600);
  5349. -  
  5350. -  /* Lock the smbpasswd file for write. */
  5351. -  if((lockfd=pw_file_lock(pfile,F_WRLCK,5))<0) {
  5352. -    err = errno;
  5353. -    fprintf(stderr, "%s: Failed to lock password file %s.\n", 
  5354. -        argv[0], pfile);
  5355. -    fclose(fp);
  5356. -    errno = err;
  5357. -    perror(argv[0]);
  5358. -    exit(err);
  5359. -  }
  5360. -
  5361. -  /* Get the smb passwd entry for this user */
  5362. -  smb_pwent = _my_get_smbpwnam(fp, pwd->pw_name, &valid_old_pwd, &seekpos);
  5363. -  if(smb_pwent == NULL) {
  5364. -    fprintf(stderr, "%s: Failed to find entry for user %s in file %s.\n",
  5365. -        argv[0], pwd->pw_name, pfile);
  5366. -    fclose(fp);
  5367. -    pw_file_unlock(lockfd);
  5368. -    exit(1);
  5369. -  }
  5370. -  
  5371. -  /* If we are root we don't need to check the old password. */
  5372. -  if( real_uid != 0) {
  5373. -    if( valid_old_pwd == False) {
  5374. -      fprintf(stderr, "%s: User %s is disabled, plase contact your administrator to enable it.\n", argv[0], pwd->pw_name);
  5375. -      fclose(fp);
  5376. -      pw_file_unlock(lockfd);
  5377. -      exit(1);
  5378. +    /* Get the real uid */
  5379. +    real_uid = getuid();
  5380. +
  5381. +    /* Deal with usage problems */
  5382. +    if (real_uid == 0) {
  5383. +        /* As root we can change anothers password. */
  5384. +        if (argc != 1 && argc != 2)
  5385. +            usage(argv[0]);
  5386. +    } else if (argc != 1)
  5387. +        usage(argv[0]);
  5388. +
  5389. +
  5390. +    if (real_uid == 0 && argc == 2) {
  5391. +        /* If we are root we can change anothers password. */
  5392. +        strncpy(user_name, argv[1], sizeof(user_name) - 1);
  5393. +        user_name[sizeof(user_name) - 1] = '\0';
  5394. +        pwd = getpwnam(user_name);
  5395. +    } else {
  5396. +        pwd = getpwuid(real_uid);
  5397. +    }
  5398. +
  5399. +    if (pwd == 0) {
  5400. +        fprintf(stderr, "%s: Unable to get UNIX password entry for user.\n", argv[0]);
  5401. +        exit(1);
  5402. +    }
  5403. +    /* If we are root we don't ask for the old password. */
  5404. +    old_passwd[0] = '\0';
  5405. +    if (real_uid != 0) {
  5406. +        p = getpass("Old SMB password:");
  5407. +        strncpy(old_passwd, p, sizeof(fstring));
  5408. +        old_passwd[sizeof(fstring)-1] = '\0';
  5409. +    }
  5410. +    new_passwd[0] = '\0';
  5411. +    p = getpass("New SMB password:");
  5412. +    strncpy(new_passwd, p, sizeof(fstring));
  5413. +    new_passwd[sizeof(fstring)-1] = '\0';
  5414. +    p = getpass("Retype new SMB password:");
  5415. +    if (strcmp(p, new_passwd)) {
  5416. +        fprintf(stderr, "%s: Mismatch - password unchanged.\n", argv[0]);
  5417. +        exit(1);
  5418. +    }
  5419. +
  5420. +    if (new_passwd[0] == '\0') {
  5421. +        printf("Password not set\n");
  5422. +        exit(0);
  5423. +    }
  5424. +
  5425. +    /* Calculate the MD4 hash (NT compatible) of the old and new passwords */
  5426. +    memset(old_nt_p16, '\0', 16);
  5427. +    E_md4hash((uchar *)old_passwd, old_nt_p16);
  5428. +
  5429. +    memset(new_nt_p16, '\0', 16);
  5430. +    E_md4hash((uchar *) new_passwd, new_nt_p16);
  5431. +
  5432. +    /* Mangle the passwords into Lanman format */
  5433. +    old_passwd[14] = '\0';
  5434. +    strupper(old_passwd);
  5435. +    new_passwd[14] = '\0';
  5436. +    strupper(new_passwd);
  5437. +
  5438. +    /*
  5439. +     * Calculate the SMB (lanman) hash functions of both old and new passwords.
  5440. +     */
  5441. +
  5442. +    memset(old_p16, '\0', 16);
  5443. +    E_P16((uchar *) old_passwd, old_p16);
  5444. +
  5445. +    memset(new_p16, '\0', 16);
  5446. +    E_P16((uchar *) new_passwd, new_p16);
  5447. +
  5448. +    /*
  5449. +     * Open the smbpaswd file XXXX - we need to parse smb.conf to get the
  5450. +     * filename
  5451. +     */
  5452. +    if ((fp = fopen(pfile, "r+")) == NULL) {
  5453. +        err = errno;
  5454. +        fprintf(stderr, "%s: Failed to open password file %s.\n",
  5455. +            argv[0], pfile);
  5456. +        errno = err;
  5457. +        perror(argv[0]);
  5458. +        exit(err);
  5459. +    }
  5460. +    /* Set read buffer to 16k for effiecient reads */
  5461. +    setvbuf(fp, readbuf, _IOFBF, sizeof(readbuf));
  5462. +
  5463. +    /* make sure it is only rw by the owner */
  5464. +    chmod(pfile, 0600);
  5465. +
  5466. +    /* Lock the smbpasswd file for write. */
  5467. +    if ((lockfd = pw_file_lock(pfile, F_WRLCK, 5)) < 0) {
  5468. +        err = errno;
  5469. +        fprintf(stderr, "%s: Failed to lock password file %s.\n",
  5470. +            argv[0], pfile);
  5471. +        fclose(fp);
  5472. +        errno = err;
  5473. +        perror(argv[0]);
  5474. +        exit(err);
  5475. +    }
  5476. +    /* Get the smb passwd entry for this user */
  5477. +    smb_pwent = _my_get_smbpwnam(fp, pwd->pw_name, &valid_old_pwd, 
  5478. +                                    &got_valid_nt_entry, &seekpos);
  5479. +    if (smb_pwent == NULL) {
  5480. +        fprintf(stderr, "%s: Failed to find entry for user %s in file %s.\n",
  5481. +            argv[0], pwd->pw_name, pfile);
  5482. +        fclose(fp);
  5483. +        pw_file_unlock(lockfd);
  5484. +        exit(1);
  5485. +    }
  5486. +    /* If we are root we don't need to check the old password. */
  5487. +    if (real_uid != 0) {
  5488. +        if ((valid_old_pwd == False) || (smb_pwent->smb_passwd == NULL)) {
  5489. +            fprintf(stderr, "%s: User %s is disabled, plase contact your administrator to enable it.\n", argv[0], pwd->pw_name);
  5490. +            fclose(fp);
  5491. +            pw_file_unlock(lockfd);
  5492. +            exit(1);
  5493. +        }
  5494. +        /* Check the old Lanman password */
  5495. +        if (memcmp(old_p16, smb_pwent->smb_passwd, 16)) {
  5496. +            fprintf(stderr, "%s: Couldn't change password.\n", argv[0]);
  5497. +            fclose(fp);
  5498. +            pw_file_unlock(lockfd);
  5499. +            exit(1);
  5500. +        }
  5501. +        /* Check the NT password if it exists */
  5502. +        if (smb_pwent->smb_nt_passwd != NULL) {
  5503. +            if (memcmp(old_nt_p16, smb_pwent->smb_nt_passwd, 16)) {
  5504. +                fprintf(stderr, "%s: Couldn't change password.\n", argv[0]);
  5505. +                fclose(fp);
  5506. +                pw_file_unlock(lockfd);
  5507. +                exit(1);
  5508. +            }
  5509. +        }
  5510. +    }
  5511. +    /*
  5512. +     * If we get here either we were root or the old password checked out
  5513. +     * ok.
  5514. +     */
  5515. +    /* Create the 32 byte representation of the new p16 */
  5516. +    for (i = 0; i < 16; i++) {
  5517. +        sprintf(&ascii_p16[i * 2], "%02X", (uchar) new_p16[i]);
  5518. +    }
  5519. +    if(got_valid_nt_entry) {
  5520. +        /* Add on the NT md4 hash */
  5521. +        ascii_p16[32] = ':';
  5522. +        for (i = 0; i < 16; i++) {
  5523. +               sprintf(&ascii_p16[(i * 2)+33], "%02X", (uchar) new_nt_p16[i]);
  5524. +        }
  5525.      }
  5526. -    /* Check the old passwd (if there was one). */
  5527. -    if(smb_pwent->smb_passwd != NULL) {
  5528. -      if( memcmp( old_p16, smb_pwent->smb_passwd, 16)) {
  5529. -    fprintf(stderr, "%s: Couldn't change password.\n", argv[0]);
  5530. +    /*
  5531. +     * Do an atomic write into the file at the position defined by
  5532. +     * seekpos.
  5533. +     */
  5534. +    pwfd = fileno(fp);
  5535. +    ret = lseek(pwfd, seekpos - 1, SEEK_SET);
  5536. +    if (ret != seekpos - 1) {
  5537. +        err = errno;
  5538. +        fprintf(stderr, "%s: seek fail on file %s.\n",
  5539. +            argv[0], pfile);
  5540. +        fclose(fp);
  5541. +        errno = err;
  5542. +        perror(argv[0]);
  5543. +        pw_file_unlock(lockfd);
  5544. +        exit(1);
  5545. +    }
  5546. +    /* Sanity check - ensure the character is a ':' */
  5547. +    if (read(pwfd, &c, 1) != 1) {
  5548. +        err = errno;
  5549. +        fprintf(stderr, "%s: read fail on file %s.\n",
  5550. +            argv[0], pfile);
  5551. +        fclose(fp);
  5552. +        errno = err;
  5553. +        perror(argv[0]);
  5554. +        pw_file_unlock(lockfd);
  5555. +        exit(1);
  5556. +    }
  5557. +    if (c != ':') {
  5558. +        fprintf(stderr, "%s: sanity check on passwd file %s failed.\n",
  5559. +            argv[0], pfile);
  5560. +        fclose(fp);
  5561. +        pw_file_unlock(lockfd);
  5562. +        exit(1);
  5563. +    }
  5564. +    writelen = (got_valid_nt_entry) ? 65 : 32;
  5565. +    if (write(pwfd, ascii_p16, writelen) != writelen) {
  5566. +        err = errno;
  5567. +        fprintf(stderr, "%s: write fail in file %s.\n",
  5568. +            argv[0], pfile);
  5569. +        fclose(fp);
  5570. +        errno = err;
  5571. +        perror(argv[0]);
  5572. +        pw_file_unlock(lockfd);
  5573. +        exit(err);
  5574. +    }
  5575.      fclose(fp);
  5576.      pw_file_unlock(lockfd);
  5577. -    exit(1);
  5578. -      }
  5579. -    }
  5580. -  }
  5581. -  /* If we get here either we were root or the old password
  5582. -     checked out ok. */
  5583. -  /* Create the 32 byte representation of the new p16 */
  5584. -  for(i = 0; i < 16; i++) {
  5585. -    sprintf(&ascii_p16[i*2], "%02X", (uchar)new_p16[i]);
  5586. -  }
  5587. -  /* Do an atomic write into the file at the position
  5588. -     defined by seekpos. */
  5589. -  pwfd = fileno(fp);
  5590. -  ret = lseek(pwfd, seekpos - 1, SEEK_SET);
  5591. -  if(ret != seekpos -1) {
  5592. -    err = errno;
  5593. -    fprintf(stderr, "%s: seek fail on file %s.\n", 
  5594. -        argv[0], pfile);
  5595. -    fclose(fp);
  5596. -    errno = err;
  5597. -    perror(argv[0]);
  5598. -    pw_file_unlock(lockfd);
  5599. -    exit(1);
  5600. -  }
  5601. -  /* Sanity check - ensure the character is a ':' */
  5602. -  if(read(pwfd,&c,1) != 1) {
  5603. -    err = errno;
  5604. -    fprintf(stderr, "%s: read fail on file %s.\n", 
  5605. -        argv[0], pfile);
  5606. -    fclose(fp);
  5607. -    errno = err;
  5608. -    perror(argv[0]);
  5609. -    pw_file_unlock(lockfd);
  5610. -    exit(1);
  5611. -  }
  5612. -  if(c != ':') {
  5613. -    fprintf(stderr, "%s: sanity check on passwd file %s failed.\n",
  5614. -        argv[0], pfile);
  5615. -    fclose(fp);
  5616. -    pw_file_unlock(lockfd);
  5617. -    exit(1);
  5618. -  }
  5619. -  if(write(pwfd,ascii_p16,32)!=32) {
  5620. -    err = errno;
  5621. -    fprintf(stderr, "%s: write fail in file %s.\n", 
  5622. -        argv[0], pfile);
  5623. -    fclose(fp);
  5624. -    errno = err;
  5625. -    perror(argv[0]);
  5626. -    pw_file_unlock(lockfd);
  5627. -    exit(err);
  5628. -  }
  5629. -  fclose(fp);
  5630. -  pw_file_unlock(lockfd);
  5631. -  printf("Password changed\n");
  5632. -  return 0;
  5633. +    printf("Password changed\n");
  5634. +    return 0;
  5635.  }
  5636.  
  5637.  #else
  5638.  
  5639.  #include "includes.h"
  5640.  
  5641. -int main(int argc, char **argv)
  5642. +int 
  5643. +main(int argc, char **argv)
  5644.  {
  5645. -  printf("smb password encryption not selected in Makefile\n");
  5646. -  return 0;
  5647. +    printf("smb password encryption not selected in Makefile\n");
  5648. +    return 0;
  5649.  }
  5650.  #endif
  5651. -
  5652. -
  5653. diff -u -r --new-file last-version/source/status.c samba-1.9.14p3/source/status.c
  5654. --- last-version/source/status.c    Sat Nov  4 23:19:07 1995
  5655. +++ samba-1.9.14p3/source/status.c    Mon Nov  6 15:55:40 1995
  5656. @@ -117,7 +117,8 @@
  5657.      else
  5658.        printf("%-10.10s   %-8s %-8s %5d   %-8s (%s) %s",
  5659.           crec.name,uidtoname(crec.uid),gidtoname(crec.gid),crec.pid,
  5660. -         crec.machine,crec.addr,asctime(LocalTime(&crec.start,0)));
  5661. +         crec.machine,crec.addr,
  5662. +         asctime(LocalTime(&crec.start,GMT_TO_LOCAL)));
  5663.        }
  5664.      }
  5665.    fclose(f);
  5666. diff -u -r --new-file last-version/source/trans2.c samba-1.9.14p3/source/trans2.c
  5667. --- last-version/source/trans2.c    Sat Nov  4 20:29:20 1995
  5668. +++ samba-1.9.14p3/source/trans2.c    Tue Nov  7 13:59:36 1995
  5669. @@ -163,7 +163,7 @@
  5670.  #if 0
  5671.    BOOL return_additional_info = BITSETW(params,0);
  5672.    int16 open_sattr = SVAL(params, 4);
  5673. -  int32 open_time = IVAL(params,8);
  5674. +  time_t open_time = make_unix_date3(params+8);
  5675.  #endif
  5676.    int16 open_ofun = SVAL(params,12);
  5677.    int32 open_size = IVAL(params,14);
  5678. @@ -348,7 +348,6 @@
  5679.  
  5680.  #ifdef MANGLE_LONG_FILENAMES
  5681.    {
  5682. -    fstring fname2;
  5683.      BOOL illegal = False;
  5684.      int i;
  5685.      int l = strlen(fname);
  5686. @@ -357,8 +356,7 @@
  5687.      illegal = True;
  5688.      break;
  5689.        }
  5690. -    name_convert(fname2,fname,illegal,SNUM(cnum));
  5691. -    strcpy(fname,fname2);
  5692. +    name_map_mangle(fname,illegal,SNUM(cnum));
  5693.    }
  5694.  #endif
  5695.  
  5696. @@ -445,13 +443,15 @@
  5697.        SIVAL(p,0,mode); p += 4;
  5698.        SIVAL(p,0,strlen(fname)); p += 4;
  5699.        SIVAL(p,0,0); p += 4;
  5700. -      if (!is_8_3(fname))
  5701. -    name_convert(p+2,fname,True,SNUM(cnum));
  5702. -      else
  5703. +      if (!is_8_3(fname)) {
  5704. +    strcpy(p+2,unix2dos_format(fname,False));
  5705. +    name_map_mangle(p+2,True,SNUM(cnum));
  5706. +      } else
  5707.      *(p+2) = 0;
  5708.        strupper(p+2);
  5709.        SSVAL(p,0,strlen(p+2));
  5710.        p += 2 + 24;
  5711. +      /* name_ptr = p;  */
  5712.        strcpy(p,fname); p += strlen(p);
  5713.        break;
  5714.  
  5715. @@ -1208,8 +1208,8 @@
  5716.    switch (info_level)
  5717.      {
  5718.      case 1:
  5719. -      tvs.actime = make_unix_date2(pdata+l1_fdateLastAccess,False);
  5720. -      tvs.modtime = make_unix_date2(pdata+l1_fdateLastWrite,False);
  5721. +      tvs.actime = make_unix_date2(pdata+l1_fdateLastAccess);
  5722. +      tvs.modtime = make_unix_date2(pdata+l1_fdateLastWrite);
  5723.        mode = SVAL(pdata,l1_attrFile);
  5724.        size = IVAL(pdata,l1_cbFile);
  5725.        break;
  5726. @@ -1217,15 +1217,15 @@
  5727.      case 2:
  5728.        if(IVAL(pdata,l2_cbList) || total_data>32)
  5729.      return(ERROR(ERRDOS,ERROR_EAS_NOT_SUPPORTED));
  5730. -      tvs.actime = make_unix_date2(pdata+l1_fdateLastAccess,False);
  5731. -      tvs.modtime = make_unix_date2(pdata+l1_fdateLastWrite,False);
  5732. +      tvs.actime = make_unix_date2(pdata+l1_fdateLastAccess);
  5733. +      tvs.modtime = make_unix_date2(pdata+l1_fdateLastWrite);
  5734.        mode = SVAL(pdata,l1_attrFile);
  5735.        size = IVAL(pdata,l1_cbFile);
  5736.        break;
  5737.  
  5738.      case 3:
  5739. -      tvs.actime = make_unix_date2(pdata+8,False);
  5740. -      tvs.modtime = make_unix_date2(pdata+12,False);
  5741. +      tvs.actime = make_unix_date2(pdata+8);
  5742. +      tvs.modtime = make_unix_date2(pdata+12);
  5743.        size = IVAL(pdata,16);
  5744.        mode = IVAL(pdata,24);
  5745.        break;
  5746. @@ -1233,8 +1233,8 @@
  5747.      case 4:
  5748.        if (IVAL(pdata,28) != 0 || total_data>36)
  5749.      return(ERROR(ERRDOS,ERROR_EAS_NOT_SUPPORTED));    
  5750. -      tvs.actime = make_unix_date2(pdata+8,False);
  5751. -      tvs.modtime = make_unix_date2(pdata+12,False);
  5752. +      tvs.actime = make_unix_date2(pdata+8);
  5753. +      tvs.modtime = make_unix_date2(pdata+12);
  5754.        size = IVAL(pdata,16);
  5755.        mode = IVAL(pdata,24);
  5756.        break;
  5757. diff -u -r --new-file last-version/source/updatesmbpasswd.sh samba-1.9.14p3/source/updatesmbpasswd.sh
  5758. --- last-version/source/updatesmbpasswd.sh    Thu Jan  1 10:00:00 1970
  5759. +++ samba-1.9.14p3/source/updatesmbpasswd.sh    Sun Nov  5 15:47:33 1995
  5760. @@ -0,0 +1,14 @@
  5761. +#!/bin/sh
  5762. +nawk 'BEGIN {FS=":"} 
  5763. +{
  5764. +    if( $0 ~ "^#" ) {
  5765. +        print $0
  5766. +    } else if( (length($4) == 32) && (($4 ~ "^[0-9A-F]*$") || ($4 ~ "^[X]*$") || ( $4 ~ "^[*]*$"))) {
  5767. +        print $0
  5768. +    } else {
  5769. +        printf( "%s:%s:%s:XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX:", $1, $2, $3);
  5770. +        for(i = 4; i <= NF; i++)
  5771. +            printf("%s:", $i)
  5772. +        printf("\n")
  5773. +    }
  5774. +}'
  5775. diff -u -r --new-file last-version/source/util.c samba-1.9.14p3/source/util.c
  5776. --- last-version/source/util.c    Sat Nov  4 22:14:20 1995
  5777. +++ samba-1.9.14p3/source/util.c    Tue Nov  7 18:24:45 1995
  5778. @@ -288,6 +288,11 @@
  5779.    tm_local = *(localtime(&t));
  5780.  
  5781.    timediff = mktime(&tm_utc) - mktime(&tm_local);
  5782. +
  5783. +  if (serverzone == 0) {
  5784. +    serverzone = timediff - DSTDiff(t);
  5785. +    DEBUG(4,("Serverzone is %d\n",serverzone));
  5786. +  }
  5787.  }
  5788.  
  5789.  
  5790. @@ -365,20 +370,10 @@
  5791.  int TimeDiff(time_t t)
  5792.  {
  5793.    static BOOL initialised = False;
  5794. -  if (!initialised) {TimeInit(); initialised=True;}
  5795. +  if (!initialised) {initialised=True; TimeInit();}
  5796.    return(timediff - DSTDiff(t));
  5797.  }
  5798.  
  5799. -
  5800. -/****************************************************************************
  5801. -try to optimise the timelocal call, it can be quite expenive on some machines
  5802. -****************************************************************************/
  5803. -static time_t TimeLocal(struct tm *tm,int timemul)
  5804. -{
  5805. -  time_t ret = mktime(tm);
  5806. -  return(ret + timemul * TimeDiff(ret));
  5807. -}
  5808. -
  5809.  /****************************************************************************
  5810.  try to optimise the localtime call, it can be quite expenive on some machines
  5811.  timemul is normally LOCAL_TO_GMT, GMT_TO_LOCAL or 0
  5812. @@ -387,7 +382,8 @@
  5813.  {
  5814.    time_t t2 = *t;
  5815.  
  5816. -  t2 += timemul * TimeDiff(t2);
  5817. +  if (timemul)
  5818. +    t2 += timemul * TimeDiff(t2);
  5819.  
  5820.    return(gmtime(&t2));
  5821.  }
  5822. @@ -680,6 +676,15 @@
  5823.  char *StrCpy(char *dest,char *src)
  5824.  {
  5825.    char *d = dest;
  5826. +
  5827. +#if AJT
  5828. +  /* I don't want to get lazy with these ... */
  5829. +  if (!dest || !src) {
  5830. +    DEBUG(0,("ERROR: NULL StrCpy() called!\n"));
  5831. +    ajt_panic();
  5832. +  }
  5833. +#endif
  5834. +
  5835.    if (!dest) return(NULL);
  5836.    if (!src) {
  5837.      *dest = 0;
  5838. @@ -830,14 +835,15 @@
  5839.  /*******************************************************************
  5840.    check if a directory exists
  5841.  ********************************************************************/
  5842. -BOOL directory_exist(char *dname)
  5843. +BOOL directory_exist(char *dname,struct stat *st)
  5844.  {
  5845. -  struct stat st;
  5846. +  struct stat st2;
  5847. +  if (!st) st = &st2;
  5848.  
  5849. -  if (sys_stat(dname,&st) != 0) 
  5850. +  if (sys_stat(dname,st) != 0) 
  5851.      return(False);
  5852.  
  5853. -  return(S_ISDIR(st.st_mode));
  5854. +  return(S_ISDIR(st->st_mode));
  5855.  }
  5856.  
  5857.  /*******************************************************************
  5858. @@ -851,6 +857,16 @@
  5859.    return(buf.st_size);
  5860.  }
  5861.  
  5862. +/****************************************************************************
  5863. +check if it's a null mtime
  5864. +****************************************************************************/
  5865. +static BOOL null_mtime(time_t mtime)
  5866. +{
  5867. +  if (mtime == 0 || mtime == 0xFFFFFFFF)
  5868. +    return(True);
  5869. +  return(False);
  5870. +}
  5871. +
  5872.  /*******************************************************************
  5873.    create a 16 bit dos packed date
  5874.  ********************************************************************/
  5875. @@ -875,6 +891,7 @@
  5876.  
  5877.  /*******************************************************************
  5878.    create a 32 bit dos packed date/time from some parameters
  5879. +  This takes a GMT time and returns a packed localtime structure
  5880.  ********************************************************************/
  5881.  static uint32 make_dos_date(time_t unixdate)
  5882.  {
  5883. @@ -891,6 +908,7 @@
  5884.  
  5885.  /*******************************************************************
  5886.  put a dos date into a buffer (time/date format)
  5887. +This takes GMT time and puts local time in the buffer
  5888.  ********************************************************************/
  5889.  void put_dos_date(char *buf,int offset,time_t unixdate)
  5890.  {
  5891. @@ -900,6 +918,7 @@
  5892.  
  5893.  /*******************************************************************
  5894.  put a dos date into a buffer (date/time format)
  5895. +This takes GMT time and puts local time in the buffer
  5896.  ********************************************************************/
  5897.  void put_dos_date2(char *buf,int offset,time_t unixdate)
  5898.  {
  5899. @@ -908,6 +927,17 @@
  5900.    SIVAL(buf,offset,x);
  5901.  }
  5902.  
  5903. +/*******************************************************************
  5904. +put a dos 32 bit "unix like" date into a buffer. This routine takes
  5905. +GMT and converts it to LOCAL time before putting it (most SMBs assume
  5906. +localtime for this sort of date)
  5907. +********************************************************************/
  5908. +void put_dos_date3(char *buf,int offset,time_t unixdate)
  5909. +{
  5910. +  if (!null_mtime(unixdate))
  5911. +    unixdate += GMT_TO_LOCAL*TimeDiff(unixdate);
  5912. +  SIVAL(buf,offset,unixdate);
  5913. +}
  5914.  
  5915.  /*******************************************************************
  5916.    interpret a 32 bit dos packed date/time to some parameters
  5917. @@ -928,9 +958,10 @@
  5918.  }
  5919.  
  5920.  /*******************************************************************
  5921. -  create a unix date from a dos date
  5922. +  create a unix date (int GMT) from a dos date (which is actually in
  5923. +  localtime)
  5924.  ********************************************************************/
  5925. -time_t make_unix_date(void *date_ptr,BOOL add_dst)
  5926. +time_t make_unix_date(void *date_ptr)
  5927.  {
  5928.    uint32 dos_date=0;
  5929.    struct tm t;
  5930. @@ -945,17 +976,18 @@
  5931.    t.tm_wday = 1;
  5932.    t.tm_yday = 1;
  5933.    t.tm_isdst = -1;
  5934. -
  5935. -  ret = TimeLocal(&t,GMT_TO_LOCAL);
  5936. +  
  5937. +  /* mktime() also does the local to GMT time conversion for us. XXXXX
  5938. +     Do all unixes do this the same?? */
  5939. +  ret = mktime(&t);
  5940.  
  5941. -  if (add_dst) ret += DSTDiff(ret);
  5942.    return(ret);
  5943.  }
  5944.  
  5945.  /*******************************************************************
  5946. -  create a unix date from a dos date
  5947. +like make_unix_date() but the words are reversed
  5948.  ********************************************************************/
  5949. -time_t make_unix_date2(void *date_ptr,BOOL add_dst)
  5950. +time_t make_unix_date2(void *date_ptr)
  5951.  {
  5952.    uint32 x,x2;
  5953.  
  5954. @@ -963,9 +995,20 @@
  5955.    x2 = ((x&0xFFFF)<<16) | ((x&0xFFFF0000)>>16);
  5956.    SIVAL(&x,0,x2);
  5957.  
  5958. -  return(make_unix_date((void *)&x,add_dst));
  5959. +  return(make_unix_date((void *)&x));
  5960.  }
  5961.  
  5962. +/*******************************************************************
  5963. +  create a unix GMT date from a dos date in 32 bit "unix like" format
  5964. +these generally arrive as localtimes, with corresponding DST
  5965. +********************************************************************/
  5966. +time_t make_unix_date3(void *date_ptr)
  5967. +{
  5968. +  time_t t = IVAL(date_ptr,0);
  5969. +  if (!null_mtime(t))
  5970. +    t += LOCAL_TO_GMT*TimeDiff(t);
  5971. +  return(t);
  5972. +}
  5973.  
  5974.  /*******************************************************************
  5975.  return a string representing an attribute for a file
  5976. @@ -988,13 +1031,24 @@
  5977.  
  5978.  
  5979.  /*******************************************************************
  5980. +  case insensitive string compararison
  5981. +********************************************************************/
  5982. +int StrCaseCmp(char *s, char *t)
  5983. +{
  5984. +  for (; tolower(*s) == tolower(*t); ++s, ++t)
  5985. +    if (!*s) return 0;
  5986. +
  5987. +  return tolower(*s) - tolower(*t);
  5988. +}
  5989. +
  5990. +/*******************************************************************
  5991.    compare 2 strings 
  5992.  ********************************************************************/
  5993.  BOOL strequal(char *s1,char *s2)
  5994.  {
  5995.    if (!s1 || !s2) return(False);
  5996.    
  5997. -  return(strcasecmp(s1,s2)==0);
  5998. +  return(StrCaseCmp(s1,s2)==0);
  5999.  }
  6000.  
  6001.  /*******************************************************************
  6002. @@ -1877,10 +1931,6 @@
  6003.  ****************************************************************************/
  6004.  int read_udp_socket(int fd,char *buf,int len)
  6005.  {
  6006. -  /* #define NORECVFROM */
  6007. -#ifdef NORECVFROM
  6008. -  return(read_data(fd,buf,len));
  6009. -#else
  6010.    int ret;
  6011.    struct sockaddr sock;
  6012.    int socklen;
  6013. @@ -1901,7 +1951,6 @@
  6014.      DEBUG(3,("read %d bytes\n",ret));
  6015.  
  6016.    return(ret);
  6017. -#endif
  6018.  }
  6019.  
  6020.  /****************************************************************************
  6021. @@ -2539,7 +2588,7 @@
  6022.  /****************************************************************************
  6023.  send a single packet to a port on another machine
  6024.  ****************************************************************************/
  6025. -BOOL send_packet(char *buf,int len,struct in_addr *ip,int port,int type)
  6026. +BOOL send_one_packet(char *buf,int len,struct in_addr *ip,int port,int type)
  6027.  {
  6028.    BOOL ret;
  6029.    int out_fd;
  6030. @@ -2620,7 +2669,7 @@
  6031.      if (strcmp(tok,s) == 0)
  6032.        return(True);
  6033.        } else {
  6034. -    if (strcasecmp(tok,s) == 0)
  6035. +    if (StrCaseCmp(tok,s) == 0)
  6036.        return(True);
  6037.        }
  6038.      }
  6039. @@ -3261,18 +3310,6 @@
  6040.    return(ret);
  6041.  }
  6042.  
  6043. -
  6044. -/****************************************************************************
  6045. -check if it's a null mtime
  6046. -****************************************************************************/
  6047. -static BOOL null_mtime(time_t mtime)
  6048. -{
  6049. -  if (mtime == 0 || mtime == 0xFFFFFFFF)
  6050. -    return(True);
  6051. -  return(False);
  6052. -}
  6053. -
  6054. -
  6055.  /****************************************************************************
  6056.  set the time on a file
  6057.  ****************************************************************************/
  6058. @@ -3612,11 +3649,16 @@
  6059.    return(res);
  6060.  }
  6061.  
  6062. -#define TIME_FIXUP_CONSTANT (369.0*365.25*24*60*60 - (3.0*24*60*60 + 6.0*60*60))
  6063. +#define TIME_FIXUP_CONSTANT (369.0*365.25*24*60*60-(3.0*24*60*60+6.0*60*60))
  6064.  
  6065.  /****************************************************************************
  6066.  interpret an 8 byte "filetime" structure to a time_t
  6067.  It's originally in "100ns units since jan 1st 1601"
  6068. +
  6069. +It appears to be kludge-GMT (at least for file listings). This means
  6070. +its the GMT you get by taking a localtime and adding the
  6071. +serverzone. This is NOT the same as GMT in some cases. This routine
  6072. +converts this to real GMT.
  6073.  ****************************************************************************/
  6074.  time_t interpret_long_date(char *p)
  6075.  {
  6076. @@ -3635,30 +3677,42 @@
  6077.    /* now adjust by 369 years to make the secs since 1970 */
  6078.    d -= TIME_FIXUP_CONSTANT;
  6079.  
  6080. +  if (d>=MAXINT)
  6081. +    return(0);
  6082. +
  6083.    ret = (time_t)(d+0.5);
  6084.  
  6085. +  /* this takes us from kludge-GMT to real GMT */
  6086. +  ret += TimeDiff(ret) - serverzone;
  6087. +
  6088.    return(ret);
  6089.  }
  6090.  
  6091.  
  6092.  /****************************************************************************
  6093.  put a 8 byte filetime from a time_t
  6094. +This takes real GMT as input and converts to kludge-GMT
  6095.  ****************************************************************************/
  6096.  void put_long_date(char *p,time_t t)
  6097.  {
  6098.    uint32 tlow,thigh;
  6099. -  double d = (double) (t);
  6100. +  double d;
  6101.  
  6102.    if (t==0) {
  6103.      SIVAL(p,0,0); SIVAL(p,4,0);
  6104.      return;
  6105.    }
  6106.  
  6107. +  /* this converts GMT to kludge-GMT */
  6108. +  t -= TimeDiff(t) - serverzone; 
  6109. +
  6110. +  d = (double) (t);
  6111. +
  6112.    d += TIME_FIXUP_CONSTANT;
  6113.  
  6114. -  d /= 1.0e-7;
  6115. +  d *= 1.0e7;
  6116.  
  6117. -  thigh = (uint32)(d / (4.0*(double)(1<<30)));
  6118. +  thigh = (uint32)(d * (1.0/(4.0*(double)(1<<30))));
  6119.    tlow = (uint32)(d - ((double)thigh)*4.0*(double)(1<<30));
  6120.  
  6121.    SIVAL(p,0,tlow);
  6122. @@ -3800,7 +3854,7 @@
  6123.  #ifdef LINUX
  6124.    fstring s;
  6125.    sprintf(s,"/proc/%d",pid);
  6126. -  return(directory_exist(s));
  6127. +  return(directory_exist(s,NULL));
  6128.  #else
  6129.    {
  6130.      static BOOL tested=False;
  6131. @@ -4137,8 +4191,8 @@
  6132.  
  6133.  int
  6134.  rename (zfrom, zto)
  6135. -     char const  *zfrom;
  6136. -     char const *zto;
  6137. +     char *zfrom;
  6138. +     char *zto;
  6139.  {
  6140.    if (link (zfrom, zto) < 0)
  6141.      {
  6142. @@ -4151,19 +4205,6 @@
  6143.    return unlink (zfrom);
  6144.  }
  6145.  
  6146. -#endif
  6147. -
  6148. -#ifdef NOSTRCASECMP
  6149. -/*******************************************************************
  6150. -  case insensitive string compararison
  6151. -********************************************************************/
  6152. -int strcasecmp(char *s, char *t)
  6153. -{
  6154. -  for (; tolower(*s) == tolower(*t); ++s, ++t)
  6155. -    if (!*s) return 0;
  6156. -
  6157. -  return tolower(*s) - tolower(*t);
  6158. -}
  6159.  #endif
  6160.  
  6161.  #if WRAP_MEMCPY
  6162. diff -u -r --new-file last-version/source/version.h samba-1.9.14p3/source/version.h
  6163. --- last-version/source/version.h    Sat Nov  4 23:21:27 1995
  6164. +++ samba-1.9.14p3/source/version.h    Tue Nov  7 23:00:33 1995
  6165. @@ -1 +1 @@
  6166. -#define VERSION "1.9.14p2"
  6167. +#define VERSION "1.9.14p3"
  6168.